liveshot/tests/card/main.js

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
module.exports = {
    Renderer:require('./src/renderer/Renderer'),
    ShotRenderer:require('./src/renderer/ShotRenderer'),
    TargetRenderer:require('./src/renderer/TargetRenderer'),
    TriangleRenderer:require('./src/renderer/TriangleRenderer'),
    CardRenderer:require('./src/renderer/CardRenderer'),
    MegalinkCardRenderer:require('./src/renderer/megalink/MegalinkCardRenderer'),
    RangeRenderer:require('./src/renderer/RangeRenderer'),
    MegalinkRangeRenderer:require('./src/renderer/megalink/MegalinkRangeRenderer'),
    Scaler:require('./src/scaler/Scaler'),
    RingTargetBuilder:require('./src/target/RingTargetBuilder'),
    RingTargetRenderer:require('./src/renderer/RingTargetRenderer'),
    RingTargetScaler:require('./src/scaler/RingTargetScaler'),
    targets:require('./src/target/targets'),
    Builder:require('./src/protocol/Builder'),
    CardBuilder:require('./src/protocol/CardBuilder'),
    ConfigBuilder:require('./src/protocol/ConfigBuilder'),
    RangeBuilder:require('./src/protocol/RangeBuilder'),
    ResultBuilder:require('./src/protocol/ResultBuilder'),
    ShooterBuilder:require('./src/protocol/ShooterBuilder'),
    ShotBuilder:require('./src/protocol/ShotBuilder')
};

},{"./src/protocol/Builder":3,"./src/protocol/CardBuilder":4,"./src/protocol/ConfigBuilder":5,"./src/protocol/RangeBuilder":6,"./src/protocol/ResultBuilder":7,"./src/protocol/ShooterBuilder":8,"./src/protocol/ShotBuilder":9,"./src/renderer/CardRenderer":10,"./src/renderer/RangeRenderer":13,"./src/renderer/Renderer":14,"./src/renderer/RingTargetRenderer":15,"./src/renderer/ShotRenderer":16,"./src/renderer/TargetRenderer":17,"./src/renderer/TriangleRenderer":18,"./src/renderer/megalink/MegalinkCardRenderer":19,"./src/renderer/megalink/MegalinkRangeRenderer":20,"./src/scaler/RingTargetScaler":23,"./src/scaler/Scaler":24,"./src/target/RingTargetBuilder":25,"./src/target/targets":37}],2:[function(require,module,exports){
if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  };
} else {
  // old school shim for old browsers
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    var TempCtor = function () {}
    TempCtor.prototype = superCtor.prototype
    ctor.prototype = new TempCtor()
    ctor.prototype.constructor = ctor
  }
}

},{}],3:[function(require,module,exports){
function Builder() {
    this.reset();
}

module.exports = Builder;

// --- Static methods ---
Builder.blankCopy = function (defaultObject) {
    return cloneDeep(defaultObject);
};

Builder.sanitize = function (rawObject, defaultObject) {
    return set(rawObject, this.blankCopy(defaultObject));
};

// --- Non-static methods ---
Builder._default = {};

Builder.prototype.reset = function () {
    this._object = Builder.blankCopy(this.constructor._default);

    return this;
};

Builder.prototype.getObject = function () {
    return cloneDeep(this._object);
};

Builder.prototype.setObject = function (rawObject) {
    this._object = Builder.sanitize(rawObject, this.constructor._default);

    return this;
};

// --- Internal helpers ---
/** Copies all existing fields in 'to' from 'from' */
function set(from, to) {
    for (var key in to) {
        if (!from.hasOwnProperty(key)) {
            continue;
        }

        var value = from[key];

        if (value instanceof Array) {
            to[key] = [].concat(value);
        } else {
            to[key] = value;
        }
    }

    return to;
}

function clone(object) {
    var copy = {};

    for (var key in object) {
        var value = object[key];

        if (value instanceof Array) {
            copy[key] = [].concat(value);
        } else {
            copy[key] = value;
        }
    }

    return copy;
}

function cloneDeep(object) {
    if (!(object instanceof Object)) {
        return object;
    }

    var copy = {};

    for (var key in object) {
        var value = object[key];

        if (value instanceof Array) {
            copy[key] = [];

            for (var idx in value) {
                copy[key].push(cloneDeep(value[idx]));
            }
        } else {
            copy[key] = cloneDeep(value);
        }
    }

    return copy;
}

},{}],4:[function(require,module,exports){
var Builder = require('./Builder');
var inherits = require('inherits');
var ConfigBuilder = require('./ConfigBuilder');
var ResultBuilder = require('./ResultBuilder');
var ShooterBuilder = require('./ShooterBuilder');

function CardBuilder() {
    this.initialize();
    this.reset();
}

module.exports = CardBuilder;
inherits(CardBuilder, Builder);

CardBuilder._default = {
    lane:'',
    shooter:ShooterBuilder.createBlankShooter(),
    result:ResultBuilder.createBlankResult(),
    config:ConfigBuilder.createBlankConfig()
};

// --- External API ---
CardBuilder.createBlankCard = function () {
    return Builder.blankCopy(this._default);
};

CardBuilder.sanitizeCard = function (rawCard) {
    var card = Builder.sanitize(rawCard, this._default);

    card.shooter = ShooterBuilder.sanitizeShooter(card.shooter);
    card.result = ResultBuilder.sanitizeResult(card.result);
    card.config = ConfigBuilder.sanitizeConfig(card.config);

    return card;
};

CardBuilder.prototype.reset = function () {
    Builder.prototype.reset.apply(this);

    this._object.shooter = this._shooterBuilder.reset().getShooter();
    this._object.result = this._resultBuilder.reset().getResult();
    this._object.config = this._configBuilder.reset().getConfig();

    return this;
};

CardBuilder.prototype.getCard = function () {
    return this.getObject();
};

// --- Bulk setters ---
CardBuilder.prototype.setCard = function (card) {
    this.setObject(card);

    this.setConfig(card.config || {});
    this.setResult(card.result || {});
    this.setShooter(card.shooter || {});

    return this;
};

CardBuilder.prototype.setConfig = function (config) {
    this._object.config = this._configBuilder.setConfig(config).getConfig();

    return this;
};

CardBuilder.prototype.setResult = function (result) {
    this._object.result = this._resultBuilder.setResult(result).getResult();

    return this;
};

CardBuilder.prototype.setShooter = function (shooter) {
    this._object.shooter = this._shooterBuilder.setShooter(shooter).getShooter();

    return this;
};

// --- Fine grained setters ---
CardBuilder.prototype.setLane = function (lane) {
    this._object.lane = lane;

    return this;
};

CardBuilder.prototype.setName = function (name) {
    this._object.shooter = this._shooterBuilder.setName(name).getShooter();

    return this;
};

CardBuilder.prototype.setClub = function (club) {
    this._object.shooter = this._shooterBuilder.setClub(club).getShooter();

    return this;
};

CardBuilder.prototype.setClassName = function (className) {
    this._object.shooter = this._shooterBuilder.setClassName(className).getShooter();

    return this;
};

CardBuilder.prototype.setCategory = function (category) {
    this._object.shooter = this._shooterBuilder.setCategory(category).getShooter();

    return this;
};

CardBuilder.prototype.setSeriesName = function (seriesName) {
    this._object.result = this._resultBuilder.setSeriesName(seriesName).getResult();

    return this;
};

CardBuilder.prototype.setSeriesSum = function (seriesSum) {
    this._object.result = this._resultBuilder.setSeriesSum(seriesSum).getResult();

    return this;
};

CardBuilder.prototype.setTotalSum = function (totalSum) {
    this._object.result = this._resultBuilder.setTotalSum(totalSum).getResult();

    return this;
};

CardBuilder.prototype.setMarking = function (marking) {
    this._object.result = this._resultBuilder.setMarking(marking).getResult();

    return this;
};

CardBuilder.prototype.setGaugeSize = function (gaugeSize) {
    this._object.config = this._configBuilder.setGaugeSize(gaugeSize).getConfig();

    return this;
};

CardBuilder.prototype.setTargetID = function (targetID) {
    this._object.config = this._configBuilder.setTargetID(targetID).getConfig();

    return this;
};

CardBuilder.prototype.setShots = function (shots) {
    this._object.result = this._resultBuilder.setShots(shots).getResult();

    return this;
};

CardBuilder.prototype.resetShots = function () {
    this._object.result = this._resultBuilder.resetShots().getResult();

    return this;
};

CardBuilder.prototype.addShot = function (shot) {
    this._object.result = this._resultBuilder.addShot(shot).getResult();

    return this;
};

CardBuilder.prototype.addShotData = function (x, y, value) {
    this._object.result = this._resultBuilder.addShotData(x, y, value).getResult();

    return this;
};

// --- Internal API ---
CardBuilder.prototype.initialize = function () {
    this._shooterBuilder = new ShooterBuilder();
    this._resultBuilder = new ResultBuilder();
    this._configBuilder = new ConfigBuilder();
};

},{"./Builder":3,"./ConfigBuilder":5,"./ResultBuilder":7,"./ShooterBuilder":8,"inherits":2}],5:[function(require,module,exports){
var Builder = require('./Builder');
var inherits = require('inherits');

function ConfigBuilder() {
    this.reset();
}

module.exports = ConfigBuilder;
inherits(ConfigBuilder, Builder);

ConfigBuilder._default = {
    gaugeSize:.02,
    targetID:'NO_DFS_200M'
};

ConfigBuilder.createBlankConfig = function () {
    return Builder.blankCopy(this._default);
};

ConfigBuilder.sanitizeConfig = function (config) {
    return Builder.sanitize(config, this._default);
};

ConfigBuilder.prototype.getConfig = function () {
    return this.getObject();
};

ConfigBuilder.prototype.setConfig = function (config) {
    return this.setObject(config);
};

ConfigBuilder.prototype.setGaugeSize = function (gaugeSize) {
    this._object.gaugeSize = gaugeSize;

    return this;
};

ConfigBuilder.prototype.setTargetID = function (targetID) {
    this._object.targetID = targetID;

    return this;
};

},{"./Builder":3,"inherits":2}],6:[function(require,module,exports){
var Builder = require('./Builder');
var inherits = require('inherits');

function RangeBuilder() {
    this.reset();
};

module.exports = RangeBuilder;
inherits(RangeBuilder, Builder);

RangeBuilder._default = {
    host:'',
    name:'',
    relay:''
};

// --- External API ---
RangeBuilder.createBlankRange = function () {
    return Builder.blankCopy(this._default);
};

RangeBuilder.sanitizeRange = function (rawRange) {
    return Builder.sanitize(rawRange, this._default);
};

RangeBuilder.prototype.getRange = function () {
    return this.getObject();
};

RangeBuilder.prototype.setRange = function (range) {
    this.setObject(range);

    return this;
};

// --- Fine grained setters ---
RangeBuilder.prototype.setHost = function (host) {
    this._object.host = host;

    return this;
};

RangeBuilder.prototype.setName = function (name) {
    this._object.name = name;

    return this;
};

RangeBuilder.prototype.setRelay = function (relay) {
    this._object.relay = relay;

    return this;
};

},{"./Builder":3,"inherits":2}],7:[function(require,module,exports){
var Builder = require('./Builder');
var ShotBuilder = require('./ShotBuilder');
var inherits = require('inherits');

function ResultBuilder() {
    this.initialize();
    this.reset();
}

module.exports = ResultBuilder;
inherits(ResultBuilder, Builder);

ResultBuilder._default = {
    seriesName:'',
    seriesSum:'',
    totalSum:'',
    marking:false,
    shots:[]
};

// --- External API ---
ResultBuilder.createBlankResult = function () {
    return Builder.blankCopy(this._default);
};

ResultBuilder.sanitizeResult = function (rawResult) {
    var result = Builder.sanitize(rawResult, this._default);

    for (var key in result.shots) {
        result.shots[key] = ShotBuilder.sanitizeShot(result.shots[key]);
    }

    return result;
};

ResultBuilder.prototype.resetShots = function () {
    this._object.shots = [];

    return this;
};

ResultBuilder.prototype.getResult = function () {
    return this.getObject();
};

ResultBuilder.prototype.setResult = function (result) {
    this.setObject(result);
    this.setShots(result.shots || []);

    return this;
};

ResultBuilder.prototype.setSeriesName = function (seriesName) {
    this._object.seriesName = seriesName;

    return this;
};

ResultBuilder.prototype.setSeriesSum = function (seriesSum) {
    this._object.seriesSum = seriesSum;

    return this;
};

ResultBuilder.prototype.setTotalSum = function (totalSum) {
    this._object.totalSum = totalSum;

    return this;
};

ResultBuilder.prototype.setMarking = function (marking) {
    this._object.marking = marking;

    return this;
};

ResultBuilder.prototype.setShots = function (shots) {
    this.resetShots();

    for (var idx in shots) {
        this.addShot(ShotBuilder.sanitizeShot(shots[idx]));
    }

    return this;
};

ResultBuilder.prototype.addShot = function (shot) {
    this._object.shots.push(shot);

    return this;
};

ResultBuilder.prototype.addShotData = function (x, y, value) {
    var shot = this._shotBuilder.reset()
        .setPosition(x, y)
        .setValue(value)
        .getShot();

    return this.addShot(shot);
};

// --- Internal API ---
ResultBuilder.prototype.initialize = function () {
    this._shotBuilder = new ShotBuilder();
};

},{"./Builder":3,"./ShotBuilder":9,"inherits":2}],8:[function(require,module,exports){
var Builder = require('./Builder');
var inherits = require('inherits');

function ShooterBuilder() {
    this.reset();
}

module.exports = ShooterBuilder;
inherits(ShooterBuilder, Builder);

ShooterBuilder._default = {
    name:'',
    club:'',
    className:'',
    category:''
};

ShooterBuilder.createBlankShooter = function () {
    return Builder.blankCopy(this._default);
};

ShooterBuilder.sanitizeShooter = function (shooter) {
    return Builder.sanitize(shooter, this._default);
};

ShooterBuilder.prototype.getShooter = function () {
    return this.getObject();
};

ShooterBuilder.prototype.setShooter = function (shooter) {
    return this.setObject(shooter);
};

ShooterBuilder.prototype.setName = function (name) {
    this._object.name = name;

    return this;
};

ShooterBuilder.prototype.setClub = function (club) {
    this._object.club = club;

    return this;
};

ShooterBuilder.prototype.setClassName = function (className) {
    this._object.className = className;

    return this;
};

ShooterBuilder.prototype.setCategory = function (category) {
    this._object.category = category;

    return this;
};

},{"./Builder":3,"inherits":2}],9:[function(require,module,exports){
var Builder = require('./Builder');
var inherits = require('inherits');

function ShotBuilder() {
    this.reset();
}

module.exports = ShotBuilder;
inherits(ShotBuilder, Builder);

ShotBuilder._default = {
    x:0,
    y:0,
    value:''
};

ShotBuilder.createBlankShot = function () {
    return Builder.blankCopy(this._default);
};

ShotBuilder.sanitizeShot = function (shot) {
    return Builder.sanitize(shot, this._default);
};

ShotBuilder.prototype.getShot = function () {
    return this.getObject();
};

ShotBuilder.prototype.setShot = function (shot) {
    return this.setObject(shot);
};

ShotBuilder.prototype.setPosition = function (x, y) {
    this.setX(x);
    this.setY(y);

    return this;
};

ShotBuilder.prototype.setX = function (x) {
    this._object.x = x;

    return this;
};

ShotBuilder.prototype.setY = function (y) {
    this._object.y = y;

    return this;
};

ShotBuilder.prototype.setValue = function (value) {
    this._object.value = value;

    return this;
};

},{"./Builder":3,"inherits":2}],10:[function(require,module,exports){
var inherits = require('inherits');
var targets = require('../target/targets');

var Renderer = require('./Renderer');
var TriangleRenderer = require('./TriangleRenderer');
var CardBuilder = require('../protocol/CardBuilder');

function CardRenderer() {
    Renderer.prototype.constructor.apply(this);

    this.initialize();
}

module.exports = CardRenderer;
inherits(CardRenderer, Renderer);

// --- External API ---
CardRenderer.prototype.setStyle = function (style) {
    for (var key in this.style) {
        if (style.hasOwnProperty(key))
            this.style[key] = style[key];
    }

    this.targetRenderer.setStyle(style);
    this.shotRenderer.setStyle(style);
    this.triangleRenderer.setStyle(style);

    return this;
};

CardRenderer.prototype.setCard = function (card, valid) {
    if (!valid) {
        card = CardBuilder.sanitizeCard(card);
    }

    this.card = card;

    this.setTarget(this.card.config.targetID);
    this.setGaugeSize(this.card.config.gaugeSize);
    this.setShots(this.card.result.shots);

    return this;
};

// --- Internal API ---
CardRenderer.prototype.initialize = function () {
    this.style = {
        backColor:'rgb(255, 255, 255)',
        frontColor:'rgb(0, 0, 0)'
    };

    this.triangleRenderer = new TriangleRenderer();

    this.setCard(CardBuilder.createBlankCard());
};

CardRenderer.prototype.draw = function () {
    this.updateScale();

    this.drawTarget();
    this.drawShots();
    this.drawTriangle();
};

CardRenderer.prototype.updateScale = function () {
    var prevScale = this.scale;
    this.scale = this.scaler.getScale();

    this.targetRenderer.setScale(this.scale);
    this.shotRenderer.setScale(this.scale);

    if (prevScale && prevScale > this.scale) {
        this.clearTarget();
    }
};

CardRenderer.prototype.clearTarget = function () {
    var targetRect = this.getTargetRect();

    this.context.clearRect(targetRect.x, targetRect.y, targetRect.width, targetRect.height);
};

CardRenderer.prototype.drawTarget = function () {
    this.targetRenderer.render();
};

CardRenderer.prototype.drawShots = function () {
    this.shotRenderer.render();
};

CardRenderer.prototype.drawTriangle = function () {
    if (!this.card.result.marking) {
        this.triangleRenderer.render();
    }
};

CardRenderer.prototype.setPosition = function (x, y) {
    var res = Renderer.prototype.setPosition.apply(this, [x, y]);

    this.updateTargetRect();

    return res;
};

CardRenderer.prototype.setSize = function (width, height) {
    var res = Renderer.prototype.setSize.apply(this, [width, height]);

    this.updateTargetRect();

    return res;
};

CardRenderer.prototype.setRect = function (rect) {
    var res = Renderer.prototype.setRect.apply(this, [rect]);

    this.updateTargetRect();

    return res;
};

CardRenderer.prototype.updateTargetRect = function () {
    var targetRect = this.getTargetRect();

    this.targetRenderer.setRect(targetRect);
    this.shotRenderer.setRect(targetRect);
    this.triangleRenderer.setRect(targetRect);
};

CardRenderer.prototype.setContext = function (context) {
    var res = Renderer.prototype.setContext.apply(this, [context]);

    this.targetRenderer.setContext(this.context);
    this.shotRenderer.setContext(this.context);
    this.triangleRenderer.setContext(this.context);

    return this;
};

CardRenderer.prototype.setTarget = function (targetID) {
    if (this.targetID == targetID) {
        return;
    }

    this.targetID = targetID;

    this.scaler = targets.getScaler(this.targetID);

    var targetStyle = this.targetRenderer ? this.targetRenderer.style : {};
    this.targetRenderer = targets.getTargetRenderer(this.targetID);
    this.targetRenderer.setStyle(targetStyle);

    var shotStyle = this.shotRenderer ? this.shotRenderer.style : {};
    this.shotRenderer = targets.getShotRenderer(this.targetID);
    this.shotRenderer.setStyle(targetStyle);

    this.setRect(this.rect);
    this.setContext(this.context);
};

CardRenderer.prototype.setShots = function (shots) {
    if (this.shots == shots) {
        return;
    }

    this.shots = shots;

    this.scaler.setShots(shots);
    this.shotRenderer.setShots(shots);
};

CardRenderer.prototype.setGaugeSize = function (gaugeSize) {
    if (this.gaugeSize == gaugeSize) {
        return;
    }

    this.gaugeSize = gaugeSize;
    this.shotRenderer.setStyle({gaugeSize:gaugeSize});
};

// --- Helper methods ---
CardRenderer.prototype.getTargetRect = function () {
    return CardRenderer.getTargetRect(this.rect);
};

CardRenderer.getTargetRect = function (rect) {
    return rect;
};

},{"../protocol/CardBuilder":4,"../target/targets":37,"./Renderer":14,"./TriangleRenderer":18,"inherits":2}],11:[function(require,module,exports){
var ShotRenderer = require('./ShotRenderer');
var ISSFSilhouetteFinalPistolTargetRenderer = require('./ISSFSilhouetteFinalPistolTargetRenderer');

function ISSFSilhouetteFinalPistolShotRenderer() {
    ShotRenderer.prototype.constructor.apply(this);
}

ISSFSilhouetteFinalPistolShotRenderer.prototype = new ShotRenderer();
ISSFSilhouetteFinalPistolShotRenderer.prototype.constructor = ISSFSilhouetteFinalPistolShotRenderer;
module.exports = ISSFSilhouetteFinalPistolShotRenderer;

ISSFSilhouetteFinalPistolShotRenderer.prototype.initialize = function () {
    ShotRenderer.prototype.initialize.apply(this);

    this.style.markerSize = 0.025;
    this.style.missedMarkerColor = this.style.lastMarkerColor;
    this.style.hitMarkerColor = this.style.markerColor;
};

ISSFSilhouetteFinalPistolShotRenderer.prototype.drawShots = function () {
    // draw first n-1 shots
    var i = 0;
    var targetSpacing = ISSFSilhouetteFinalPistolTargetRenderer.TARGET_SPACING;
    var targetWidth = (1 - 6*targetSpacing)/5;

    for (var idx in this.shots) {
        var shot = this.shots[idx];
        var j = 4 - i;

        if (shot.value !== '-1 ') {
            this.drawShot({
                x: shot.x*targetWidth/2 + ((j + 1)*targetSpacing + (j + 0.5)*targetWidth) - 0.5,
                y: shot.y*targetWidth/2,
                value: shot.value
            }, shot.value === '1 ' ? this.style.hitMarkerColor : this.style.missedMarkerColor);
        }

        ++i;
    }
};

ISSFSilhouetteFinalPistolShotRenderer.prototype.getShotScale = function () {
    return this.scale*this.rect.width;
};

},{"./ISSFSilhouetteFinalPistolTargetRenderer":12,"./ShotRenderer":16}],12:[function(require,module,exports){
var TargetRenderer = require('./TargetRenderer');
var RingTargetRenderer = require('./RingTargetRenderer');

function ISSFSilhouetteFinalPistolTargetRenderer() {
    TargetRenderer.prototype.constructor.apply(this);
}

ISSFSilhouetteFinalPistolTargetRenderer.prototype = new TargetRenderer();
ISSFSilhouetteFinalPistolTargetRenderer.prototype.constructor = ISSFSilhouetteFinalPistolTargetRenderer;
ISSFSilhouetteFinalPistolTargetRenderer.TARGET_SPACING = 0.02;
module.exports = ISSFSilhouetteFinalPistolTargetRenderer;

// --- External API ---
ISSFSilhouetteFinalPistolTargetRenderer.prototype.setTarget = function (target) {
    this.renderer.setTarget(target);

    return this;
};

ISSFSilhouetteFinalPistolTargetRenderer.prototype.setStyle = function (style) {
    var ret = TargetRenderer.prototype.setStyle.apply(this, [style]);
    this.renderer.setStyle(style);

    return ret;
};

ISSFSilhouetteFinalPistolTargetRenderer.prototype.setContext = function (context) {
    var ret = TargetRenderer.prototype.setContext.apply(this, [context]);
    this.renderer.setContext(context);

    return ret;
};

// --- Internal API ---
ISSFSilhouetteFinalPistolTargetRenderer.prototype.initialize = function () {
    TargetRenderer.prototype.initialize.apply(this);

    this.renderer = new RingTargetRenderer()
        .setScale(1);
};

ISSFSilhouetteFinalPistolTargetRenderer.prototype.render = function () {
    this.context.fillStyle = this.style.backColor;
    this.context.fillRect(this.rect.x, this.rect.y, this.rect.width, this.rect.height);

    var width = this.rect.width;
    var targetSpacing = ISSFSilhouetteFinalPistolTargetRenderer.TARGET_SPACING;
    var targetWidth = width*(1 - 6*targetSpacing)/5;

    // draw each of the five targets
    for (var i = 0; i < 5; ++i) {
        var rect = {
            x: this.rect.x + targetWidth*i + width*targetSpacing*(i + 1),
            y: this.rect.y,
            width: targetWidth,
            height: this.rect.height
        };

        this.renderer.setRect(rect);
        this.renderer.render();
    }
};

},{"./RingTargetRenderer":15,"./TargetRenderer":17}],13:[function(require,module,exports){
var inherits = require('inherits');

var Renderer = require('./Renderer');
var CardRenderer = require('./CardRenderer');
var RangeBuilder = require('../protocol/RangeBuilder');

function RangeRenderer() {
    Renderer.prototype.constructor.apply(this);

    this.initialize();
}

module.exports = RangeRenderer;
inherits(RangeRenderer, Renderer);

// --- External API ---
RangeRenderer.prototype.setStyle = function (style) {
    for (var key in style) {
        this.rawStyle[key] = style[key];
    }

    for (var key in this.style) {
        if (style.hasOwnProperty(key))
            this.style[key] = style[key];
    }

    for (var idx in this.cardRenderers) {
        this.cardRenderers[idx].setStyle(style);
    }

    return this;
};

RangeRenderer.prototype.setRange = function (range, valid) {
    if (!valid) {
        range = RangeBuilder.sanitizeRange(range);
    }

    this.range = range;

    return this;
};

RangeRenderer.prototype.setCards = function (cards, valid) {
    // add new cards
    for (var idx in cards) {
        this.setCard(idx, cards[idx], valid, true);
    }

    // remove old new cards
    for (var idx in this.cardRenderers) {
        if (!cards.hasOwnProperty(idx)) {
            this.removeCard(idx, true);
        }
    }

    this.pushCardRects();

    return this;
};

RangeRenderer.prototype.setCard = function (idx, card, valid, maintainRects) {
    if (!this.cardRenderers.hasOwnProperty(idx)) {
        this.addCardRenderer(idx);

        if (!maintainRects) {
            this.pushCardRects();
        }
    }

    this.cardRenderers[idx].setCard(card, valid);

    return this;
};

RangeRenderer.prototype.removeCard = function (idx, maintainRects) {
    this.removeCardRenderer(idx);

    if (!maintainRects) {
        this.pushCardRects();
    }

    return this;
};

// --- Internal API ---
RangeRenderer.prototype.initialize = function () {
    this.cardRenderers = {};
    this.rawStyle = {};
    this.style = {};
    this.numCardRenderers = 0;

    this.setRange(RangeBuilder.createBlankRange());
};

RangeRenderer.prototype.setContext = function (context) {
    var res = Renderer.prototype.setContext.apply(this, [context]);

    for (var idx in this.cardRenderers) {
        this.cardRenderers[idx].setContext(this.context);
    }

    return res;
};

RangeRenderer.prototype.setRect = function (rect) {
    var res = Renderer.prototype.setRect.apply(this, [rect]);

    this.pushCardRects();

    return res;
};

RangeRenderer.prototype.addCardRenderer = function (idx) {
    var renderer = new this.CardRenderer();
    renderer.setContext(this.context);
    renderer.setStyle(this.rawStyle);

    this.cardRenderers[idx] = renderer;

    ++this.numCardRenderers;
};

RangeRenderer.prototype.removeCardRenderer = function (idx) {
    delete this.cardRenderers[idx];
    --this.numCardRenderers;
};

RangeRenderer.prototype.draw = function () {
    for (var idx in this.cardRenderers) {
        this.cardRenderers[idx].render();
    }
};

RangeRenderer.prototype.pushCardRects = function () {
    var rect = this.getCardsRect();
    var layout = this.getCardsLayout();

    var cardNum = 0;
    var cardIndices = this.getCardIndices();
    var cardWidth = rect.width/layout.numCols;
    var cardHeight = rect.height/layout.numRows;

    for (var i = 0; i < layout.numRows; ++i) {
        for (var j = 0; j < layout.numCols; ++j) {
            if (cardNum >= cardIndices.length) {
                return;
            }

            var cardIdx = cardIndices[cardNum++];

            var leftEdge = Math.floor(j*cardWidth) + rect.x;
            var rightEdge = Math.floor((j + 1)*cardWidth) + rect.x;
            var topEdge = Math.floor(i*cardHeight) + rect.y;
            var bottomEdge = Math.floor((i + 1)*cardHeight) + rect.y;

            this.cardRenderers[cardIdx].setRect({
                x: leftEdge,
                y: topEdge,
                width: rightEdge - leftEdge,
                height: bottomEdge - topEdge
            });
        }
    }
};

RangeRenderer.prototype.getCardIndices = function () {
    var indices = [];

    for (var idx in this.cardRenderers) {
        indices.push(idx);
    }

    return indices;
};

RangeRenderer.prototype.CardRenderer = CardRenderer;

// --- Layout utils ---
RangeRenderer.prototype.getCardsRect = function () {
    return this.rect;
};

RangeRenderer.prototype.getCardsLayout = function () {
    var rect = this.getCardsRect();
    var N = this.numCardRenderers;
    var minBadness = Number.MAX_VALUE;
    var bestM = 0;
    var bestN = 0;

    if (N == 5 || N == 7) {
        ++N;
    }

    for (var m = 1; m <= N; ++m) {
        var n = Math.ceil(N / m);
        var cardWidth = rect.width/n;
        var cardHeight = rect.height/m;
        var targetRect = this.CardRenderer.getTargetRect({x: 0, y: 0, width: cardWidth, height: cardHeight});

        var aspectRatio = targetRect.width / targetRect.height;
        var optimalRatio = 1;
        var ratioBadness =  Math.abs(aspectRatio - optimalRatio) + Math.abs(1/aspectRatio - 1/optimalRatio);
        var cellCountBadness = Math.abs(n*m - N);
        var badness = ratioBadness + cellCountBadness;

        if (badness < minBadness) {
            minBadness = badness;
            bestM = m;
            bestN = n;
        }
    }

    return {
        numCols: bestN,
        numRows: bestM
    };
};

},{"../protocol/RangeBuilder":6,"./CardRenderer":10,"./Renderer":14,"inherits":2}],14:[function(require,module,exports){
function Renderer() {
    this.rect = {
        x:0,
        y:0,
        width:0,
        height:0
    };
}

module.exports = Renderer;

// --- External API ---
Renderer.prototype.render = function () {
    var ctx = this.context;

    ctx.save();

    this.clipContext();
    this.draw();

    ctx.restore();

    return this;
};

Renderer.prototype.setPosition = function (x, y) {
    this.rect.x = x;
    this.rect.y = y;

    return this;
};

Renderer.prototype.setSize = function (width, height) {
    this.rect.width = width;
    this.rect.height = height;

    return this;
};

Renderer.prototype.setRect = function (rect) {
    this.rect = rect;

    return this;
};

Renderer.prototype.setContext = function (context) {
    this.context = context;

    return this;
};

// --- Internal API ---
Renderer.prototype.centerContext = function () {
    var ctx = this.context;

    ctx.translate(this.rect.x, this.rect.y);
    ctx.translate(this.rect.width/2, this.rect.height/2);
};

Renderer.prototype.draw = function () {
    // to be overloaded
};

Renderer.prototype.clipContext = function () {
    var ctx = this.context;

    ctx.save();
    this.centerContext();

    ctx.beginPath();
    ctx.rect(-this.rect.width/2, -this.rect.height/2, this.rect.width, this.rect.height);
    ctx.closePath();
    ctx.restore();

    ctx.clip();
};

},{}],15:[function(require,module,exports){
var TargetRenderer = require('./TargetRenderer');

function RingTargetRenderer() {
    TargetRenderer.prototype.constructor.apply(this);

    this.style.drawFullTarget = false;
    this.style.ringLineWidth = .75;
}

RingTargetRenderer.prototype = new TargetRenderer();
RingTargetRenderer.prototype.constructor = RingTargetRenderer;
module.exports = RingTargetRenderer;

// --- External API ---
RingTargetRenderer.prototype.setTarget = function (target) {
    this.target = target;

    return this;
};

// --- Internal API ---
RingTargetRenderer.prototype.drawTarget = function () {
    this.drawBackground();
    this.drawRings();
    this.drawNumbers();
};

RingTargetRenderer.prototype.drawBackground = function () {
    var ctx = this.context;
    var size = this.getSize();

    // draw back
    var backSize = this.getMaxSize();
    ctx.fillStyle = this.style.backColor;

    ctx.beginPath();
    ctx.arc(0, 0, backSize * size, 0, Math.PI*2, true);
    ctx.closePath();
    ctx.fill();

    // draw front
    var frontSize = Math.min(this.target.frontSize, this.getMaxSize());
    ctx.fillStyle = this.style.frontColor;

    ctx.beginPath();
    ctx.arc(0, 0, frontSize * size, 0, Math.PI*2, true);
    ctx.closePath();
    ctx.fill();

    // draw sight lines
    if (this.target.drawSightLines) {
        ctx.beginPath();
        ctx.fillStyle = this.style.backColor;
        ctx.fillRect(-frontSize*size, -0.01*frontSize*size, frontSize*size/2, 0.02*frontSize*size);
        ctx.fillStyle = this.style.backColor;
        ctx.fillRect(frontSize*size/2, -0.01*frontSize*size, frontSize*size/2, 0.02*frontSize*size);
        ctx.closePath();
        ctx.fill();
    }
};

RingTargetRenderer.prototype.drawRings = function () {
    var ctx = this.context;
    var frontSize = this.target.frontSize;
    var ringSizes = this.target.ringSizes;
    var size = this.getSize();
    var pixelRatio = window.devicePixelRatio || 1;

    for (var idx in ringSizes) {
        var ringSize = ringSizes[idx];

        if (ringSize == frontSize || ringSize > this.getMaxSize()) {
            continue;
        }

        var radius = ringSize*size;
        var isFrontRing = ringSize <= frontSize;
        ctx.strokeStyle = isFrontRing
            ? this.style.backColor
            : this.style.frontColor;
        ctx.lineWidth = this.style.ringLineWidth*pixelRatio;

        ctx.beginPath();
        ctx.arc(0, 0, radius, 0, Math.PI*2, true);
        ctx.closePath();

        ctx.stroke();

        if (isFrontRing && this.target.drawSightLines && ringSize > 0.5*frontSize) {
            var dh = 0.01*frontSize*size;
            var alpha = Math.asin(dh/radius);

            ctx.strokeStyle = this.style.frontColor;
            ctx.beginPath();
            ctx.arc(0, 0, radius, -alpha, alpha, false);
            ctx.closePath();

            ctx.stroke();

            ctx.beginPath();
            ctx.arc(0, 0, radius, Math.PI - alpha, Math.PI + alpha, false);
            ctx.closePath();

            ctx.stroke();
        }
    }
};

RingTargetRenderer.prototype.drawNumbers = function () {
    var ctx = this.context;
    var size = this.getSize();

    for (var i = 0; i + 1 < this.target.ringSizes.length
            && i + this.target.numbersFrom <= this.target.numbersTo; ++i) {
        var number = i + this.target.numbersFrom;
        var lowerRingSize = this.target.ringSizes[i];
        var upperRingSize = this.target.ringSizes[i + 1];

        if (lowerRingSize > this.getMaxSize()) {
            continue;
        }

        var d = (lowerRingSize + upperRingSize) / 2 * size;

        if (lowerRingSize > this.target.frontSize) {
            ctx.fillStyle = this.style.frontColor;
        } else {
            ctx.fillStyle = this.style.backColor;
        }

        if (this.target.drawHorisontalNumbers) {
            this.drawNumber(number, -d, 0);
            this.drawNumber(number, d, 0);
        }

        if (this.target.drawVerticalNumbers) {
            this.drawNumber(number, 0, -d);
            this.drawNumber(number, 0, d);
        }
    }
};

RingTargetRenderer.prototype.drawNumber = function (number, dx, dy) {
    var ctx = this.context;
    var size = this.getSize();

    ctx.font = "36px arial";
    ctx.textBaseline = "middle";
    ctx.textAlign = "center";

    ctx.save();
    ctx.translate(dx, dy);
    ctx.scale(1/500 * size, 1/500 * size);

    ctx.fillText(number, 0, 0);

    ctx.restore();
};

RingTargetRenderer.prototype.getSize = function () {
    return this.scale * Math.min(this.rect.width, this.rect.height)/2;
};

RingTargetRenderer.prototype.getMaxSize = function () {
    var maxSize = 1;

    if (!this.style.drawFullTarget)
        maxSize = Math.min(maxSize, 1 / this.scale);

    return maxSize;
};

},{"./TargetRenderer":17}],16:[function(require,module,exports){
var Renderer = require('./Renderer');

function ShotRenderer() {
    Renderer.prototype.constructor.apply(this);

    this.initialize();
}

ShotRenderer.prototype = new Renderer();
ShotRenderer.prototype.constructor = ShotRenderer;
module.exports = ShotRenderer;

// --- External API ---
ShotRenderer.prototype.setStyle = function (style) {
    for (var key in this.style) {
        if (style.hasOwnProperty(key))
            this.style[key] = style[key];
    }

    return this;
};

ShotRenderer.prototype.setShots = function (shots) {
    this.shots = shots;

    return this;
};

ShotRenderer.prototype.setScale = function (scale) {
    this.scale = scale;

    return this;
};

// --- Internal API ---
ShotRenderer.prototype.initialize = function () {
    this.scale = 1;
    this.shots = {};
    this.style = {
        gaugeSize:.015,
        gaugeColor:'rgb(0, 0, 0)',
        markerSize:.05,
        markerColor:'rgb(0, 255, 0)',
        lastMarkerColor:'rgb(255, 0, 0)'
    };
};

ShotRenderer.prototype.draw = function () {
    var ctx = this.context;
    ctx.save();

    this.centerContext();
    this.drawShots();

    ctx.restore();
};

ShotRenderer.prototype.drawShots = function () {
    // draw first n-1 shots
    var shot = null;
    for (var idx in this.shots) {
        if (shot) {
            this.drawShot(shot, this.style.markerColor);
        }

        shot = this.shots[idx];
    }

    // draw last shot with special color
    if (shot)
        this.drawShot(shot, this.style.lastMarkerColor);
};

ShotRenderer.prototype.drawShot = function (shot, markerColor) {
    var ctx = this.context;
    var scale = this.getShotScale();

    ctx.save();
    ctx.scale(scale, scale);
    ctx.translate(shot.x, shot.y);

    if (this.style.gaugeSize > .7*this.style.markerSize) {
        this.renderShotWithoutGauge(shot, markerColor, scale);
    } else {
        this.renderShotWithGauge(shot, markerColor);
    }

    ctx.restore();
};

ShotRenderer.prototype.renderShotWithGauge = function (shot, markerColor) {
    var ctx = this.context;

    // draw marker
    ctx.beginPath();
    ctx.arc(0, 0, this.style.markerSize, 0, Math.PI*2, true);
    ctx.closePath();

    ctx.fillStyle = markerColor;
    ctx.fill();

    // draw gauge
    ctx.beginPath();
    ctx.arc(0, 0, this.style.gaugeSize, 0, Math.PI*2, true);
    ctx.closePath();

    ctx.fillStyle = this.style.gaugeColor;
    ctx.fill();
};

ShotRenderer.prototype.renderShotWithoutGauge = function (shot, markerColor, scale) {
    var ctx = this.context;
    var pixelRatio = window.devicePixelRatio || 1;
    ctx.save();

    ctx.beginPath();
    ctx.arc(0, 0, this.style.gaugeSize, 0, Math.PI*2, true);
    ctx.closePath();

    ctx.fillStyle = markerColor;
    ctx.fill();

    ctx.scale(1/scale, 1/scale);
    ctx.strokeStyle = this.style.gaugeColor;
    ctx.lineWidth = .5*pixelRatio;
    ctx.stroke();

    ctx.restore();
};

ShotRenderer.prototype.getShotScale = function () {
    return this.scale * Math.min(this.rect.width, this.rect.height)/2;
};

},{"./Renderer":14}],17:[function(require,module,exports){
var Renderer = require('./Renderer');

function TargetRenderer() {
    Renderer.prototype.constructor.apply(this);

    this.initialize();
}

TargetRenderer.prototype = new Renderer();
TargetRenderer.prototype.constructor = TargetRenderer;
module.exports = TargetRenderer;

// --- External API ---
TargetRenderer.prototype.setStyle = function (style) {
    for (var key in this.style) {
        if (style.hasOwnProperty(key))
            this.style[key] = style[key];
    }

    return this;
};

TargetRenderer.prototype.setScale = function (scale) {
    this.scale = scale;

    return this;
};

// --- Internal API ---
TargetRenderer.prototype.initialize = function () {
    this.scale = 1;
    this.style = {
        backColor:'rgb(255, 255, 255)',
        frontColor:'rgb(0, 0, 0)'
    };
};

TargetRenderer.prototype.draw = function () {
    var ctx = this.context;
    ctx.save();

    this.centerContext();
    this.drawTarget();

    ctx.restore();
};

TargetRenderer.prototype.drawTarget = function () {
    // to be overloaded
};

},{"./Renderer":14}],18:[function(require,module,exports){
var Renderer = require('./Renderer');

function TriangleRenderer() {
    Renderer.prototype.constructor.apply(this);

    this.initialize();
}

TriangleRenderer.prototype = new Renderer();
TriangleRenderer.prototype.constructor = TriangleRenderer;
module.exports = TriangleRenderer;

// --- External API ---
TriangleRenderer.prototype.setStyle = function (style) {
    for (var key in this.style) {
        if (style.hasOwnProperty(key))
            this.style[key] = style[key];
    }

    return this;
};

// --- Internal API ---
TriangleRenderer.prototype.initialize = function () {
    this.style = {
        color:'rgb(150, 150, 150)',
        borderColor:'rgb(50, 50, 50)',
        size:.2
    };
};

TriangleRenderer.prototype.draw = function () {
    var ctx = this.context;
    var size = this.style.size;
    var pixelRatio = window.devicePixelRatio || 1;

    ctx.save();

    ctx.translate(this.rect.x, this.rect.y);
    ctx.scale(this.rect.width, this.rect.width);

    ctx.beginPath();
    ctx.moveTo(1, 0);
    ctx.lineTo(1 - size, 0);
    ctx.lineTo(1, size);
    ctx.closePath();

    ctx.fillStyle = this.style.color;
    ctx.fill();

    ctx.beginPath();
    ctx.moveTo(1 - size, 0);
    ctx.lineTo(1, size);
    ctx.closePath();

    ctx.scale(1/this.rect.width, 1/this.rect.width);

    ctx.strokeStyle = this.style.borderColor;
    ctx.lineWidth = .5*pixelRatio;
    ctx.stroke();

    ctx.restore();
};

},{"./Renderer":14}],19:[function(require,module,exports){
var inherits = require('inherits');
var CardRenderer = require('../CardRenderer');
var utils = require('./utils');

// --- Constants ---
var MARGINH = 5;
var MARGINV = 3;

var MAX_SHOTS = 10;

var BACKGROUND_COLOR = 'rgb(255, 255, 255)';
var FRONT_COLOR = 'rgb(0, 0, 0)';

var GAUGE_COLOR = 'rgb(0, 0, 0)';
var MARKER_COLOR = 'rgb(0, 255, 0)';
var LAST_MARKER_COLOR = 'rgb(255, 0, 0)';

var TRIANGLE_COLOR = 'rgb(200, 200, 200)';
var TRIANGLE_BORDER_COLOR = 'rgb(150, 150, 150)';

var LANE_NUMBER_BACK_COLOR = 'rgba(64, 64, 64, 0.7)';
var LANE_NUMBER_FRONT_COLOR = 'rgb(245, 245, 245)';

function MegalinkCardRenderer() {
    CardRenderer.prototype.constructor.apply(this);
}

module.exports = MegalinkCardRenderer;
inherits(MegalinkCardRenderer, CardRenderer);

// --- Internal API ---
MegalinkCardRenderer.prototype.initialize = function () {
    CardRenderer.prototype.initialize.apply(this);

    this.style.backColor = BACKGROUND_COLOR;
    this.style.frontColor = FRONT_COLOR;

    this.shotRenderer.setStyle({
        gaugeColor: GAUGE_COLOR,
        markerColor: MARKER_COLOR,
        lastMarkerColor: LAST_MARKER_COLOR
    });

    this.triangleRenderer.setStyle({
        color: TRIANGLE_COLOR,
        borderColor: TRIANGLE_BORDER_COLOR
    });
};

MegalinkCardRenderer.prototype.setTarget = function (targetId) {
    CardRenderer.prototype.setTarget.apply(this, [targetId]);

    this.targetRenderer.setStyle({
        drawFullTarget:true
    });
};

MegalinkCardRenderer.prototype.draw = function () {
    CardRenderer.prototype.draw.apply(this);

    this.drawLaneNumber();
    this.drawHeader();
    this.drawShotList();
    this.drawSums();
};

MegalinkCardRenderer.prototype.drawTarget = function () {
    CardRenderer.prototype.drawTarget.apply(this);

    utils.strokeFrame(this.context, MegalinkCardRenderer.getTargetRect(this.rect), this.style.frontColor);
};

MegalinkCardRenderer.prototype.drawLaneNumber = function () {
    var rect = MegalinkCardRenderer.getLaneNumberRect(this.rect);
    var laneNumber = this.card.lane;

    this.context.fillStyle = LANE_NUMBER_BACK_COLOR;
    this.context.fillRect(rect.x, rect.y, rect.width, rect.height);

    utils.setFont(this.context, laneNumber, .8*rect.width, .8*rect.height);
    this.context.textBaseline = "middle";
    this.context.textAlign = "center";

    this.context.fillStyle = LANE_NUMBER_FRONT_COLOR;
    this.context.fillText(laneNumber, rect.x + rect.width/2, rect.y + rect.height/2);
};

MegalinkCardRenderer.prototype.drawHeader = function () {
    utils.drawFrame(this.context, MegalinkCardRenderer.getHeaderRect(this.rect), this.style.frontColor, this.style.backColor);

    this.drawName();
    this.drawClub();
    this.drawSeriesName();
    this.drawClass();
    this.drawCategory();
};

MegalinkCardRenderer.prototype.drawName = function () {
    var name = this.card.shooter.name;
    var rect = MegalinkCardRenderer.getNameRect(this.rect);

    utils.setFont(this.context, name, rect.width, rect.height);
    this.context.textBaseline = "top";
    this.context.textAlign = "left";

    this.context.fillStyle = this.style.frontColor;
    this.context.fillText(name, rect.x, rect.y);
};

MegalinkCardRenderer.prototype.drawClub = function () {
    var club = this.card.shooter.club;
    var rect = MegalinkCardRenderer.getClubRect(this.rect);

    utils.setFont(this.context, club, rect.width, rect.height);
    this.context.textBaseline = "bottom";
    this.context.textAlign = "left";

    this.context.fillStyle = this.style.frontColor;
    this.context.fillText(club, rect.x, rect.y + rect.height);
};

MegalinkCardRenderer.prototype.drawSeriesName = function () {
    var seriesName = this.card.result.seriesName;
    var rect = MegalinkCardRenderer.getSeriesNameRect(this.rect);

    utils.setFont(this.context, seriesName, rect.width, rect.height);
    this.context.textBaseline = "bottom";
    this.context.textAlign = "left";

    this.context.fillStyle = this.style.frontColor;
    this.context.fillText(seriesName, rect.x, rect.y + rect.height);
};

MegalinkCardRenderer.prototype.drawClass = function () {
    var className = this.card.shooter.className;
    var rect = MegalinkCardRenderer.getClassRect(this.rect);

    utils.setFont(this.context, className, rect.width, rect.height);
    this.context.textBaseline = "bottom";
    this.context.textAlign = "right";

    this.context.fillStyle = this.style.frontColor;
    this.context.fillText(className, rect.x + rect.width, rect.y + rect.height);
};

MegalinkCardRenderer.prototype.drawCategory = function () {
    var category = this.card.shooter.category;
    var rect = MegalinkCardRenderer.getCategoryRect(this.rect);

    utils.setFont(this.context, category, rect.width, rect.height);
    this.context.textBaseline = "bottom";
    this.context.textAlign = "right";

    this.context.fillStyle = this.style.frontColor;
    this.context.fillText(category, rect.x + rect.width, rect.y + rect.height);
};

MegalinkCardRenderer.prototype.drawShotList = function () {
    utils.drawFrame(this.context, MegalinkCardRenderer.getShotListRect(this.rect), this.style.frontColor, this.style.backColor);

    this.drawShotListFrame();
    this.drawShotListContent();
};

MegalinkCardRenderer.prototype.drawShotListFrame = function () {
    var rect = MegalinkCardRenderer.getShotListRect(this.rect);

    var numRows = this.getNumRows();
    var numColumns = this.getNumColumns();
    var rowHeight = rect.height / numRows;
    var columnWidth = rect.width / numColumns;

    var pixelRatio = window.devicePixelRatio || 1;

    this.context.strokeStyle = this.style.frontColor;
    this.context.lineWidth = 1*pixelRatio;
    this.context.beginPath();

    for (var i = 1; i < numRows; ++i) {
        var y = rect.y + i*rowHeight;

        this.context.moveTo(rect.x, y);
        this.context.lineTo(rect.x + rect.width, y);
    }

    for (var i = 1; i < numColumns; ++i) {
        var x = rect.x + i*columnWidth;

        this.context.moveTo(x, rect.y);
        this.context.lineTo(x, rect.y + rect.height);
    }

    this.context.stroke();
    this.context.closePath();
};

MegalinkCardRenderer.prototype.drawShotListContent = function () {
    var offset = Math.max(0, this.card.result.shots.length - MAX_SHOTS);
    var shots = this.card.result.shots.slice(-MAX_SHOTS);
    var shotNum = 1;

    for (var idx in shots) {
        var shot = shots[idx];
        this.drawShotContent(shotNum + offset, shot, this.getShotRect(shotNum));

        ++shotNum;
    }
};

MegalinkCardRenderer.prototype.drawShotContent = function (shotNum, shot, rect) {
    utils.setFont(this.context, '10:', .4*rect.width, .9*rect.height);
    this.context.textBaseline = 'middle';
    this.context.fillStyle = this.style.frontColor;

    // draw shot number
    this.context.textAlign = 'left';
    this.context.fillText(shotNum + ':', rect.x + 5, rect.y - rect.height/2);

    // draw shot value
    this.context.textAlign = 'right';
    this.context.fillText(shot.value, rect.x + rect.width - 5, rect.y - rect.height/2);
};

MegalinkCardRenderer.prototype.getNumRows = function () {
    return 5; // XXX set as style property?
};

MegalinkCardRenderer.prototype.getNumColumns = function () {
    var numShots = 0;
    for (var idx in this.card.result.shots) ++numShots;

    return Math.min(2, Math.ceil(numShots / this.getNumRows()));
};

MegalinkCardRenderer.prototype.drawSums = function () {
    var rect = MegalinkCardRenderer.getSumsRect(this.rect);

    utils.drawFrame(this.context, rect, this.style.frontColor, this.style.backColor);

    this.context.fillStyle = this.style.frontColor;
    this.context.fillRect(rect.x + .5*rect.width, rect.y, .5*rect.width, rect.height);

    // draw text
    var seriesSum = this.card.result.seriesSum;
    var totalSum = this.card.result.totalSum;

    utils.setFont(this.context, totalSum, .6*rect.width, .6*rect.height);
    this.context.textBaseline = "middle";
    this.context.textAlign = "center";

    this.context.fillStyle = this.style.frontColor;
    this.context.fillText(seriesSum, rect.x + .25*rect.width, rect.y + .5*rect.height);

    this.context.fillStyle = this.style.backColor;
    this.context.fillText(totalSum, rect.x + .75*rect.width, rect.y + .5*rect.height);
};

// --- Rect helper methods ---
MegalinkCardRenderer.isPortrait = function (rect) {
    return rect.width / rect.height < 1;
};

MegalinkCardRenderer.prototype.getTargetRect = function () {
    return MegalinkCardRenderer.getTargetRect(this.rect);
};

MegalinkCardRenderer.getTargetRect = function (rect) {
    if (MegalinkCardRenderer.isPortrait(rect)) {
        return {
            x:rect.x,
            y:rect.y + .125*rect.height,
            width:rect.width,
            height:.5*rect.height
        }
    } else {
        return {
            x:rect.x,
            y:rect.y + .25*rect.height,
            width:.6*rect.width,
            height:.75*rect.height
        };
    }
};

MegalinkCardRenderer.getHeaderRect = function (rect) {
    if (MegalinkCardRenderer.isPortrait(rect)) {
        return {
            x:rect.x,
            y:rect.y,
            width:rect.width,
            height:.125*rect.height
        };
    } else {
        return {
            x:rect.x,
            y:rect.y,
            width:rect.width,
            height:.25*rect.height
        };
    }
};

MegalinkCardRenderer.getNameRect = function (rect) {
    var rect = MegalinkCardRenderer.getHeaderRect(rect);

    var width = rect.width;
    var height = .55*rect.height;

    return {
        x:rect.x + MARGINH,
        y:rect.y + MARGINV,
        width:width - 2*MARGINH,
        height:height - 2*MARGINV
    };
};

MegalinkCardRenderer.getClubRect = function (rect) {
    var rect = MegalinkCardRenderer.getHeaderRect(rect);

    var width = .55*rect.width;
    var height = .45*rect.height;

    return {
        x:rect.x + MARGINH,
        y:rect.y + rect.height - height + MARGINV,
        width:width - 3/2*MARGINH,
        height:height - 2*MARGINV
    };
};

MegalinkCardRenderer.getSeriesNameRect = function (rect) {
    var rect = MegalinkCardRenderer.getHeaderRect(rect);

    var width = .25*rect.width;
    var height = .45*rect.height;

    return {
        x:rect.x + .55*rect.width + MARGINH/2,
        y:rect.y + rect.height - height + MARGINV,
        width:width - MARGINH,
        height:height - 2*MARGINV
    };
};

MegalinkCardRenderer.getClassRect = function (rect) {
    var rect = MegalinkCardRenderer.getHeaderRect(rect);

    var width = .13*rect.width;
    var height = .45*rect.height;

    return {
        x:rect.x + .8*rect.width + MARGINH/2,
        y:rect.y + rect.height - height + MARGINV,
        width:width - MARGINH,
        height:height - 2*MARGINV
    };
};

MegalinkCardRenderer.getCategoryRect = function (rect) {
    var rect = MegalinkCardRenderer.getHeaderRect(rect);

    var width = .07*rect.width;
    var height = .45*rect.height;

    return {
        x:rect.x + .93*rect.width + MARGINH/2,
        y:rect.y + rect.height - height + MARGINV,
        width:width - 3/2*MARGINH,
        height:height - 2*MARGINV
    };
};

MegalinkCardRenderer.getShotListRect = function (rect) {
    if (MegalinkCardRenderer.isPortrait(rect)) {
        return {
            x:rect.x,
            y:rect.y + .625*rect.height,
            width:rect.width,
            height:.25*rect.height
        };
    } else {
        return {
            x:rect.x + .6*rect.width,
            y:rect.y + .25*rect.height,
            width:.4*rect.width,
            height:.55*rect.height
        };
    }
};

MegalinkCardRenderer.getLaneNumberRect = function (rect) {
    var targetRect = MegalinkCardRenderer.getTargetRect(rect);
    var size = Math.min(targetRect.width, targetRect.height) / 5;

    targetRect.width = size;
    targetRect.height = size;

    return targetRect;
};

MegalinkCardRenderer.getSumsRect = function (rect) {
    if (MegalinkCardRenderer.isPortrait(rect)) {
        return {
            x:rect.x,
            y:rect.y + .875*rect.height,
            width:rect.width,
            height:.125*rect.height
        };
    } else {
        return {
            x:rect.x + .6*rect.width,
            y:rect.y + .80*rect.height,
            width:.4*rect.width,
            height:.20*rect.height
        };
    }
};

MegalinkCardRenderer.prototype.getShotRect = function (shotNum) {
    var numRows = this.getNumRows();
    var numColumns = this.getNumColumns();
    var rect = MegalinkCardRenderer.getShotListRect(this.rect);

    var cellWidth = rect.width / numColumns;
    var cellHeight = rect.height / numRows;

    var j = Math.floor((shotNum - 1) / numRows);
    var i = shotNum - j*numRows;

    return {
        x:rect.x + j*cellWidth,
        y:rect.y + i*cellHeight,
        width:cellWidth,
        height:cellHeight
    };
};

},{"../CardRenderer":10,"./utils":21,"inherits":2}],20:[function(require,module,exports){
var inherits = require('inherits');

var MegalinkCardRenderer = require('./MegalinkCardRenderer');
var RangeRenderer = require('../RangeRenderer');
var utils = require('./utils');

// --- Constants ---
var HEADER_HEIGHT = 90;
var HEADER_MARGIN = 8;

function MegalinkRangeRenderer() {
    RangeRenderer.prototype.constructor.apply(this);
}

module.exports = MegalinkRangeRenderer;
inherits(MegalinkRangeRenderer, RangeRenderer);

// --- Internal API ---
MegalinkRangeRenderer.prototype.initialize = function () {
    RangeRenderer.prototype.initialize.apply(this);

    this.style.frontColor = 'rgb(0, 0, 0)';
};

MegalinkRangeRenderer.prototype.CardRenderer = MegalinkCardRenderer;

MegalinkRangeRenderer.prototype.draw = function () {
    RangeRenderer.prototype.draw.apply(this);

    this.drawHeader();
};

MegalinkRangeRenderer.prototype.drawHeader = function () {
    var ctx = this.context;
    var rect = this.getHeaderRect();

    ctx.clearRect(rect.x, rect.y, rect.width, rect.height);

    this.drawHost(rect);
    this.drawRangeRelay(rect);
    this.drawLogo(rect);
};

MegalinkRangeRenderer.prototype.drawHost = function (rect) {
    var ctx = this.context;
    var rect = MegalinkRangeRenderer.getHostRect(rect);
    var host = this.range.host;

    ctx.fillStyle = this.style.frontColor;
    utils.setFont(ctx, host, rect.width, rect.height);
    ctx.textAlign = 'center';
    ctx.textBaseline = 'middle';
    ctx.fillText(host, rect.x + rect.width/2, rect.y + rect.height/2);
    ctx.textAlign = 'left';
    ctx.textBaseline = 'alphabetic';
};

MegalinkRangeRenderer.prototype.drawRangeRelay = function (rect) {
    var ctx = this.context;
    var rangeRelay = this.range.name + ' - Lag nr ' + this.range.relay;
    var rangeRelayRect = MegalinkRangeRenderer.getRangeRelayRect(rect);

    ctx.fillStyle = this.style.frontColor;
    utils.setFont(ctx, rangeRelay, rangeRelayRect.width, rangeRelayRect.height);

    ctx.textBaseline = 'middle';
    ctx.fillText(rangeRelay, rangeRelayRect.x, rangeRelayRect.y + rangeRelayRect.height/2);
    ctx.textBaseline = 'alphabetic';
};

MegalinkRangeRenderer.prototype.drawLogo = function (rect) {
    var ctx = this.context;

    if (!this.logo || this.logo.width == 0) {
        this.logo = new Image();
        this.logo.src = 'images/mllogo.png';

        var self = this;
        this.logo.onload = function () {
            self.drawLogo(rect);
        };

        return;
    }

    var maxRect = MegalinkRangeRenderer.getLogoMaxRect(rect);

    var width = this.logo.width;
    var height = this.logo.height;
    var logoTooLarge = width > maxRect.width || height > maxRect.height;

    if (logoTooLarge) {
        var ratio = width / height;

        if (width - maxRect.width > height - maxRect.height) {
            width = maxRect.width;
            height = maxRect.width / ratio;
        } else {
            width = maxRect.height * ratio;
            height = maxRect.height;
        }
    }

    var left = rect.x + rect.width - HEADER_MARGIN - width;
    var top = rect.y + rect.height/2 - height/2;

    ctx.drawImage(this.logo, left, top, width, height);
};

// --- Rect utils ---
MegalinkRangeRenderer.prototype.getCardsRect = function (rect) {
    return MegalinkRangeRenderer.getCardsRect(this.rect);
};

MegalinkRangeRenderer.prototype.getHeaderRect = function () {
    return MegalinkRangeRenderer.getHeaderRect(this.rect);
};

MegalinkRangeRenderer.getCardsRect = function (rect) {
    return {
        x: 0,
        y: HEADER_HEIGHT,
        width: rect.width,
        height: rect.height - HEADER_HEIGHT
    };
};

MegalinkRangeRenderer.getHeaderRect = function (rect) {
    return {
        x: 0,
        y: 0,
        width: rect.width,
        height: HEADER_HEIGHT
    };
};

MegalinkRangeRenderer.getHostRect = function (rect) {
    return {
        x:rect.x + rect.width/4 + 2*HEADER_MARGIN,
        y:rect.y + 2*HEADER_MARGIN,
        width:rect.width/2 - 4*HEADER_MARGIN,
        height:rect.height - 4*HEADER_MARGIN
    };
};

MegalinkRangeRenderer.getRangeRelayRect = function (rect) {
    return {
        x:rect.x + 3*HEADER_MARGIN,
        y:rect.y + HEADER_MARGIN,
        width:rect.width/5,
        height:rect.height - 2*HEADER_MARGIN
    };
};

MegalinkRangeRenderer.getLogoMaxRect = function (rect) {
    return {
        x:rect.x + 5*rect.width/8,
        y:rect.y + HEADER_MARGIN,
        width:rect.width/4,
        height:rect.height - 2*HEADER_MARGIN
    };
};

},{"../RangeRenderer":13,"./MegalinkCardRenderer":19,"./utils":21,"inherits":2}],21:[function(require,module,exports){
module.exports = {
    drawFrame: drawFrame,
    setFont: setFont,
    strokeFrame: strokeFrame
};

function setFont(ctx, text, width, height) {
    var fontName = "arial";
    var refSize = 10;

    // get reference text width
    ctx.font = refSize + "px " + fontName;
    var refTextWidth = ctx.measureText(text).width;

    // calculate maximum textHeight
    var textHeight = Math.min(height, width/refTextWidth * refSize);

    // assemble font name
    ctx.font = textHeight + "px " + fontName;
}

function strokeFrame(ctx, rect, color) {
    var pixelRatio = window.devicePixelRatio || 1;

    ctx.strokeStyle = color;
    ctx.lineWidth = 1*pixelRatio;
    ctx.strokeRect(rect.x, rect.y, rect.width, rect.height);
}

function drawFrame(ctx, rect, frontColor, backColor) {
    ctx.fillStyle = backColor;
    ctx.fillRect(rect.x, rect.y, rect.width, rect.height);

    strokeFrame(ctx, rect, frontColor);
}

},{}],22:[function(require,module,exports){
var Scaler = require('./Scaler');

function ISSFSilhouetteFinalPistolTargetScaler() {
    Scaler.prototype.constructor.apply(this);
}

ISSFSilhouetteFinalPistolTargetScaler.prototype = new Scaler();
ISSFSilhouetteFinalPistolTargetScaler.prototype.constructor = ISSFSilhouetteFinalPistolTargetScaler;
module.exports = ISSFSilhouetteFinalPistolTargetScaler;

// --- External API ---
ISSFSilhouetteFinalPistolTargetScaler.prototype.getScale = function () {
    return 1;
};

},{"./Scaler":24}],23:[function(require,module,exports){
var Scaler = require('./Scaler');

function RingTargetScaler() {
    Scaler.prototype.constructor.apply(this);
}

RingTargetScaler.prototype = new Scaler();
RingTargetScaler.prototype.constructor = RingTargetScaler;
module.exports = RingTargetScaler;

// --- External API ---
RingTargetScaler.prototype.setTarget = function (target) {
    this.target = target;

    return this;
};

RingTargetScaler.prototype.getScale = function () {
    // find the largest distance from center to shot
    var maxDist = 0;
    var numShots = 0;
    for (var idx in this.shots) {
        var shot = this.shots[idx];
        var r = Math.sqrt(shot.x*shot.x + shot.y*shot.y);

        maxDist = Math.max(maxDist, r);
        ++numShots;
    }

    if (numShots == 0) {
        maxDist = .2;
    }

    // find rings containing all shots
    var ringSizes = [];
    for (var idx in this.target.ringSizes) {
        var ringSize = this.target.ringSizes[idx];

        if (ringSize > maxDist) {
            ringSizes.push(ringSize);
        } else {
            break;
        }
    }

    // scale to one ring larger than the smallest ring containing all shots
    var size = 1;
    if (ringSizes.length > 1) {
        size = ringSizes[ringSizes.length - 2];
    }

    return 1 / size;
};

},{"./Scaler":24}],24:[function(require,module,exports){
function Scaler() {
    this.shots = [];
}

module.exports = Scaler;

// --- External API ---
Scaler.prototype.setShots = function (shots) {
    this.shots = shots;

    return this;
};

Scaler.prototype.getScale = function () {
    // to be overloaded
};

},{}],25:[function(require,module,exports){
function RingTargetBuilder() {
    this.reset();
}

module.exports = RingTargetBuilder;

// --- External API ---
RingTargetBuilder.createBlankTarget = function () {
    var target = {
        ringSizes:[1],
        frontSize:1,
        drawVerticalNumbers:true,
        drawHorisontalNumbers:true,
        numbersFrom:1,
        numbersTo:1,
        drawSightLines:false
    };

    return target;
};

RingTargetBuilder.prototype.reset = function () {
    this.target = this.constructor.createBlankTarget();

    return this;
};

RingTargetBuilder.prototype.getTarget = function () {
    return this.target;
};

RingTargetBuilder.prototype.setRingSizes = function (ringSizes) {
    this.target.ringSizes = ringSizes;

    return this;
};

RingTargetBuilder.prototype.setFrontSize = function (frontSize) {
    this.target.frontSize = frontSize;

    return this;
};

RingTargetBuilder.prototype.setDrawVerticalNumbers = function (drawVerticalNumbers) {
    this.target.drawVerticalNumbers = !!drawVerticalNumbers;

    return this;
};

RingTargetBuilder.prototype.setDrawHorisontalNumbers = function (drawHorisontalNumbers) {
    this.target.drawHorisontalNumbers = !!drawHorisontalNumbers;

    return this;
};

RingTargetBuilder.prototype.setNumbersFrom = function (numbersFrom) {
    this.target.numbersFrom = numbersFrom;

    return this;
};

RingTargetBuilder.prototype.setNumbersTo = function (numbersTo) {
    this.target.numbersTo = numbersTo;

    return this;
};

RingTargetBuilder.prototype.setDrawSightLines = function (drawSightLines) {
    this.target.drawSightLines = !!drawSightLines;

    return this;
};

},{}],26:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(.4)
        .setNumbersFrom(1)
        .setNumbersTo(9)
        .setRingSizes([1., .9, .8, .7, .6, .5, .4, .3, .2, .1, .05])
        .getTarget();

},{"../RingTargetBuilder":25}],27:[function(require,module,exports){
module.exports = require('./DFSTenRingTarget');

},{"./DFSTenRingTarget":26}],28:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(.4578)
        .setNumbersFrom(1)
        .setNumbersTo(8)
        .setRingSizes([1., .8916, .7831, .6747, .5663, .4578, .3494, .2410, .1325, .0241])
        .getTarget();

},{"../RingTargetBuilder":25}],29:[function(require,module,exports){
module.exports=require(27)
},{"./DFSTenRingTarget":26,"/Users/martinvl/Dropbox/dev/liveshot/src/target/dfs/NO_DFS_100M.js":27}],30:[function(require,module,exports){
module.exports=require(27)
},{"./DFSTenRingTarget":26,"/Users/martinvl/Dropbox/dev/liveshot/src/target/dfs/NO_DFS_100M.js":27}],31:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(0.3826)
        .setNumbersFrom(1)
        .setNumbersTo(8)
        .setRingSizes([1., 0.8971, 0.7942, 0.6913, 0.5884, 0.4855, 0.3826, 0.2797, 0.1768, 0.0740, 0.0322])
        .getTarget();

},{"../RingTargetBuilder":25}],32:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(0.4)
        .setNumbersFrom(1)
        .setNumbersTo(9)
        .setRingSizes([1., 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.05])
        .getTarget();

},{"../RingTargetBuilder":25}],33:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(0.6703)
        .setNumbersFrom(1)
        .setNumbersTo(8)
        .setRingSizes([1., 0.8901, 0.7802, 0.6703, 0.5604, 0.4505, 0.3407, 0.2308, 0.1209, 0.0110])
        .getTarget();

},{"../RingTargetBuilder":25}],34:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(1.)
        .setDrawHorisontalNumbers(false)
        .setDrawVerticalNumbers(false)
        .setDrawSightLines(true)
        .setRingSizes([1., 0.26])
        .getTarget();

},{"../RingTargetBuilder":25}],35:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(1.)
        .setDrawHorisontalNumbers(false)
        .setDrawVerticalNumbers(false)
        .setDrawSightLines(true)
        .setRingSizes([1., 0.16])
        .getTarget();

},{"../RingTargetBuilder":25}],36:[function(require,module,exports){
var RingTargetBuilder = require('../RingTargetBuilder');

module.exports = new RingTargetBuilder()
        .setFrontSize(1.)
        .setDrawHorisontalNumbers(false)
        .setNumbersFrom(5)
        .setNumbersTo(9)
        .setDrawSightLines(true)
        .setRingSizes([1., 0.84, 0.68, 0.52, 0.36, 0.2, 0.1])
        .getTarget();

},{"../RingTargetBuilder":25}],37:[function(require,module,exports){
var RingTargetScaler = require('../scaler/RingTargetScaler');
var RingTargetRenderer = require('../renderer/RingTargetRenderer');

var ShotRenderer = require('../renderer/ShotRenderer');

var ISSFSilhouetteFinalPistolTargetScaler = require('../scaler/ISSFSilhouetteFinalPistolTargetScaler');
var ISSFSilhouetteFinalPistolTargetRenderer = require('../renderer/ISSFSilhouetteFinalPistolTargetRenderer');
var ISSFSilhouetteFinalPistolShotRenderer = require('../renderer/ISSFSilhouetteFinalPistolShotRenderer');

var targets =  {
    'NO_DFS_100M':require('./dfs/NO_DFS_100M'),
    'NO_DFS_200M':require('./dfs/NO_DFS_200M'),
    'NO_DFS_300M':require('./dfs/NO_DFS_300M'),
    'NO_DFS_15M':require('./dfs/NO_DFS_15M'),
    'INT_ISSF_PISTOL_10M':require('./issf/INT_ISSF_PISTOL_10M'),
    'INT_ISSF_RIFLE_10M':require('./issf/INT_ISSF_RIFLE_10M'),
    'INT_ISSF_PRECISION_PISTOL':require('./issf/INT_ISSF_PRECISION_PISTOL'),
    'INT_ISSF_SILHOUETTE_PISTOL':require('./issf/INT_ISSF_SILHOUETTE_PISTOL'),
    'INT_ISSF_SILHOUETTE_FINAL_PISTOL':require('./issf/INT_ISSF_SILHOUETTE_FINAL_PISTOL'),
    'INT_ISSF_SILHOUETTE_FINAL_WOMEN_PISTOL':require('./issf/INT_ISSF_SILHOUETTE_FINAL_WOMEN_PISTOL'),
    'UNKNOWN':require('./dfs/NO_DFS_100M')
};

function getTarget(targetID) {
    return targets[targetID];
}

function getScaler(targetID) {
    switch (targetID) {
        case 'NO_DFS_100M':
        case 'NO_DFS_200M':
        case 'NO_DFS_300M':
        case 'NO_DFS_15M':
        case 'INT_ISSF_PISTOL_10M':
        case 'INT_ISSF_RIFLE_10M':
        case 'INT_ISSF_PRECISION_PISTOL':
        case 'INT_ISSF_SILHOUETTE_PISTOL':
        case 'UNKNOWN':
            return new RingTargetScaler()
                .setTarget(getTarget(targetID));
        case 'INT_ISSF_SILHOUETTE_FINAL_PISTOL':
        case 'INT_ISSF_SILHOUETTE_FINAL_WOMEN_PISTOL':
            return new ISSFSilhouetteFinalPistolTargetScaler();
    }
}

function getTargetRenderer(targetID) {
    switch (targetID) {
        case 'NO_DFS_100M':
        case 'NO_DFS_200M':
        case 'NO_DFS_300M':
        case 'NO_DFS_15M':
        case 'INT_ISSF_PISTOL_10M':
        case 'INT_ISSF_RIFLE_10M':
        case 'INT_ISSF_PRECISION_PISTOL':
        case 'INT_ISSF_SILHOUETTE_PISTOL':
        case 'UNKNOWN':
            return new RingTargetRenderer()
                .setTarget(getTarget(targetID));
        case 'INT_ISSF_SILHOUETTE_FINAL_PISTOL':
        case 'INT_ISSF_SILHOUETTE_FINAL_WOMEN_PISTOL':
            return new ISSFSilhouetteFinalPistolTargetRenderer()
                .setTarget(getTarget(targetID));
    }
}

function getShotRenderer(targetID) {
    switch (targetID) {
        case 'NO_DFS_100M':
        case 'NO_DFS_200M':
        case 'NO_DFS_300M':
        case 'NO_DFS_15M':
        case 'INT_ISSF_PISTOL_10M':
        case 'INT_ISSF_RIFLE_10M':
        case 'INT_ISSF_PRECISION_PISTOL':
        case 'INT_ISSF_SILHOUETTE_PISTOL':
        case 'UNKNOWN':
            return new ShotRenderer();
        case 'INT_ISSF_SILHOUETTE_FINAL_PISTOL':
        case 'INT_ISSF_SILHOUETTE_FINAL_WOMEN_PISTOL':
            return new ISSFSilhouetteFinalPistolShotRenderer();
    }
}

module.exports = {
    getScaler:getScaler,
    getTargetRenderer:getTargetRenderer,
    getShotRenderer:getShotRenderer
};

for (var targetID in targets) {
    module.exports[targetID] = targets[targetID];
}

},{"../renderer/ISSFSilhouetteFinalPistolShotRenderer":11,"../renderer/ISSFSilhouetteFinalPistolTargetRenderer":12,"../renderer/RingTargetRenderer":15,"../renderer/ShotRenderer":16,"../scaler/ISSFSilhouetteFinalPistolTargetScaler":22,"../scaler/RingTargetScaler":23,"./dfs/NO_DFS_100M":27,"./dfs/NO_DFS_15M":28,"./dfs/NO_DFS_200M":29,"./dfs/NO_DFS_300M":30,"./issf/INT_ISSF_PISTOL_10M":31,"./issf/INT_ISSF_PRECISION_PISTOL":32,"./issf/INT_ISSF_RIFLE_10M":33,"./issf/INT_ISSF_SILHOUETTE_FINAL_PISTOL":34,"./issf/INT_ISSF_SILHOUETTE_FINAL_WOMEN_PISTOL":35,"./issf/INT_ISSF_SILHOUETTE_PISTOL":36}],38:[function(require,module,exports){
var LiveShot = require('../../../index');

var width = 300;
var height = 400;
var pixelRatio = window.devicePixelRatio || 1;

var canvas = document.createElement('canvas');
canvas.width = width*pixelRatio;
canvas.height = height*pixelRatio;
canvas.style.width = width + 'px';
canvas.style.height = height + 'px';

document.body.appendChild(canvas);

var ctx = canvas.getContext('2d');
var rect = {x:0, y:0, width:width*pixelRatio, height:height*pixelRatio};

var builder = new LiveShot.CardBuilder()
    .setLane('1')
    .setName('Martin Vonheim Larsen')
    .setClub('Rygge')
    .setClassName('4')
    .setCategory('A')
    .setTargetID('INT_ISSF_SILHOUETTE_FINAL_PISTOL')
    .setGaugeSize(5600/(500000*0.88*5))
    .setSeriesName('Ligg');

builder.resetShots()
    .setSeriesSum('5')
    .setTotalSum('5');

for (var i = 0; i < 4; ++i) {
    var gauge = 5600/(500000*0.88*5);
    var r = Math.random()*0.3;
    var theta = Math.random()*2*Math.PI;
    var x = r*Math.cos(theta);
    var y = r*Math.sin(theta);
    var value = (r - gauge/2 <= 4/25) ? '1' : '0';

    builder.addShotData(x, y, value);
}

var renderer = new LiveShot.MegalinkCardRenderer()
    .setContext(ctx)
    .setRect(rect)
    .setCard(builder.getCard())
    .render();

},{"../../../index":1}]},{},[38]);