Christmas_Tree/public/data/scripts/js/decoration.js

"use strict";
class Decoration {
    constructor(properties) {
        this.pos = p.createVector();
        this.isTaken = false;
        this.isBoundToMouse = false;
        this.isToDelete = false;
        this.needsValidation = false;
        this.isSelected = false;
        for (let key in properties) {
            if (properties.hasOwnProperty(key)) {
                if (Array.isArray(properties[key])) {
                    this[key] = arrayCopy(properties[key]);
                }
                else {
                    this[key] = properties[key];
                }
            }
        }
    }
    get properties() {
        let colors = [];
        for (let i = 0; i < this.colors.length; i++) {
            let color = [];
            for (let c of this.colors[i]) {
                color.push(c);
            }
            colors.push(color);
        }
        return {
            radius: this.radius,
            colors: colors,
            type: this.type
        };
    }
    get mouseIsOver() {
        if (this.isTaken) {
            let pos = this.realPos;
            return p.dist(pos.x, pos.y, p.mouseX, p.mouseY) <= this.radius * game.tree.sizeMultiplier;
        }
        return false;
    }
    get hasValidPosition() {
        return game.tree.containsPosition(this.realPos, true);
    }
    get realPos() {
        return p5.Vector.add(p5.Vector.mult(this.pos, game.tree.sizeMultiplier), game.center);
    }
    static Create(properties) {
        switch (properties['type']) {
            case 'ball':
                return new Ball(properties);
            case 'star':
                return new Star(properties);
            case 'chain':
                return new Chain(properties);
        }
    }
    display(pos, dim) {
        let sizeMultiplier = this.sizeMultiplier;
        if (pos || dim) {
            sizeMultiplier = dim.y * 0.6;
        }
        else {
            pos = this.pos;
        }
        p.push();
        p.translate(pos);
        p.scale(sizeMultiplier);
    }
    brightness(value) {
        p.noStroke();
        p.fill(0, 0, 0, value);
        p.ellipse(0, 0, this.radius * 2, this.radius * 2);
    }
    update() {
        if (!this.isTaken) {
            this.pos = this.container.center;
            this.sizeMultiplier = this.container.dim.y * 0.6;
        }
        else {
            this.sizeMultiplier = 1;
        }
        if (this.isBoundToMouse) {
            let x = (p.mouseX - game.center.x) / game.tree.sizeMultiplier, y = (p.mouseY - game.center.y) / game.tree.sizeMultiplier;
            this.pos.set(x, y);
        }
    }
    //Assumes mouse is over this
    mousePressed() {
        this.isBoundToMouse = true;
    }
    //Always called
    mouseReleased() {
    }
    toJSON(index) {
        let list = [
            "pos",
            "colors",
            "radius",
            "type"
        ];
        let obj = {};
        for (let item of list) {
            obj[item] = this[item];
        }
        return obj;
    }
    static restoreFrom(rawDeco) {
        let props = {};
        for (let key in rawDeco) {
            if (['pos', 'p1', 'p2'].find(s => s === key) === undefined) {
                props[key] = rawDeco[key];
            }
        }
        let deco = Decoration.Create(props);
        deco.isTaken = true;
        deco.pos.x = rawDeco['pos'].x;
        deco.pos.y = rawDeco['pos'].y;
        if (deco instanceof Chain) {
            deco.p1.set(rawDeco['p1'].x, rawDeco['p1'].y);
            deco.p2.set(rawDeco['p2'].x, rawDeco['p2'].y);
            deco.generate();
        }
        return deco;
    }
}
function darker(c) {
    let newC = [];
    for (let v of c) {
        newC.push(p.constrain(v * 0.6, 0, 255));
    }
    return newC;
}
function arrayCopy(a) {
    let newArr = [];
    for (let c of a) {
        let copy = c;
        if (Array.isArray(c)) {
            copy = arrayCopy(c);
        }
        newArr.push(copy);
    }
    return newArr;
}
function equals(a1, a2) {
    // if the other array is a falsy value, return
    if (!a1)
        return false;
    // compare lengths - can save a lot of time 
    if (a2.length != a1.length)
        return false;
    for (let i = 0, l = a2.length; i < l; i++) {
        // Check if we have nested arrays
        if (a2[i] instanceof Array && a1[i] instanceof Array) {
            // recurse into the nested arrays
            if (!a2[i].equals(a1[i]))
                return false;
        }
        else if (a2[i] != a1[i]) {
            // Warning - two different object instances will never be equal: {x:20} != {x:20}
            return false;
        }
    }
    return true;
}
//# sourceMappingURL=decoration.js.map