Planets Multiplayer Windows, Mac, Linux, Web, iOS, Android game

View complete gist here. ( Gist.github.com )
BlockStore.js

 define(function(require, exports, module){
    var _               = require('underscore');
    var utils           = require('client/utils');
    var Phaser          = require('phaser');
    var Block           = require('../actors/Block');
    var PlanetGenerator = require('client/PlanetGenerator')
    var constants       = require('client/constants');
    var EventEmitter    = require('eventEmitter');





    var BlockStore = function(options){
        _.extend(this, {
            api    : null,
            stores : {},
        },options);
        this.__shipsById             = {};
        this.__planetsById           = {};
        this.__planetsByBlockId      = [];
        this.__blocksIdByPlanetId    = {};
        this.__blocksById            = [];
        this.__blocksByPos           = {};
        this.__selectedBlocksHistory = [];
        this.__onPlanetChangeBinded  = this.__onPlanetChange.bind(this);
        this.onBlockUpdated          = new Phaser.Signal();
        this.invalidateInBoundsBlocks();
        this.generateEmptyBlocks();


        var appDispatcher  = options.appDispatcher;
        this.dispatchToken = appDispatcher.register(this.onAppDispatcherAction.bind(this))
    }





    BlockStore.getBoundingBoxStepped = function(view, step){
        // Adjusting so we don't care about negative values
        var adjustX = 0;
        if(view.x < 0){
            adjustX = step * Math.ceil(-view.x/step);
        }
        view.x += adjustX;
        var adjustY = 0;
        if(view.y < 0){
            adjustY = step * Math.ceil(-view.y/step);
        }
        view.y += adjustY;

        var leftBoundingBox = view.x - view.x % step - adjustX;
        var topBoundingBox  = view.y - view.y % step - adjustY;
        var horizontalSteps = Math.ceil((view.width  + view.x % step) / step);
        var verticalSteps   = Math.ceil((view.height + view.y % step) / step);
        var width           = step * horizontalSteps;
        var height          = step * verticalSteps;
        return {
            x               : leftBoundingBox,
            y               : topBoundingBox,
            width           : width,
            height          : height,
            horizontalSteps : horizontalSteps,
            verticalSteps   : verticalSteps,
            leftStep        : leftBoundingBox / step,
            topStep         : topBoundingBox / step,
        }
    }




    _.extend(BlockStore.prototype, EventEmitter.prototype, {
        onAppDispatcherAction: function(payload){
            var action = payload.action;
            switch(action.type){
                case 'players.unlockBlock':
                    // @todo.
                    break;

                default:
                    // do nothing
              }
        },



        selectBlock: function(block){
            this.selectedBlock = block;
            this.__selectedBlocksHistory.push(block);
        },



        getLastXSelectedBlocks: function(howMany){
            return _.last(this.__selectedBlocksHistory, howMany)
        },



        getVisibleBlocks: function(){
            var last2SelectedBlocks = this.getLastXSelectedBlocks(2);
            console.log(last2SelectedBlocks.length)
            return last2SelectedBlocks
        },



        updateAuthorizedBlocks: function(){
            var unlockedBlocksIds = this.stores.authStore.currentPlayer.unlockedBlocksIds;
            unlockedBlocksIds.forEach(function(blockId){
                var block = this.getBlockById(blockId);
                block.setAuthorized(true);
            }.bind(this))
        },



        invalidateInBoundsBlocks: function(){
            this.__inBoundsBlocksAreDirty = true;
        },



        updateInBoundsBlocks: function(){
            if(!this.__inBoundsBlocksAreDirty) return;
            // Use camera
            var cameraVisibleRect = this.stores.cameraStore.getVisibleArea();
            // Don't consider scale.
            // The origin of the blocks is (0, 0)
            var blockSize = constants.BLOCK_SIZE;
            var boundingBoxStepped = BlockStore.getBoundingBoxStepped(cameraVisibleRect, blockSize);
            var inBoundsBlocksIds  = [];
            var inBoundsBlocksById = {};
            var inBoundsBlocks     = [];
            var block;
            var currentPlayer = this.stores.authStore.currentPlayer;
            for(var x = boundingBoxStepped.leftStep; x < boundingBoxStepped.leftStep + boundingBoxStepped.horizontalSteps; x++){
                for(var y = boundingBoxStepped.topStep; y < boundingBoxStepped.topStep + boundingBoxStepped.verticalSteps; y++){
                    block = this.getBlockByXY(x, y);
                    // if(currentPlayer.unlockedBlocksIds.indexOf(block._id) === -1) continue;
                    inBoundsBlocksIds.push(block._id);
                    inBoundsBlocks.push(block);
                    inBoundsBlocksById[block._id] = block;
                }
            }
            this.__inBoundsBlocksIds      = inBoundsBlocksIds;
            this.__inBoundsBlocksById     = inBoundsBlocksById;
            this.__inBoundsBlocks         = inBoundsBlocks;
            this.__inBoundsBlocksAreDirty = false;
        },



        getInBoundsBlocks: function(){
            this.updateInBoundsBlocks();
            return this.__inBoundsBlocks;
        },



        getInBoundsBlocksIds: function(){
            this.updateInBoundsBlocks();
            return this.__inBoundsBlocksIds;
        },



        getInBoundsBlocksById: function(){
            this.updateInBoundsBlocks();
            return this.__inBoundsBlocksById;
        },



        getRenderedBlocks: function(){
            return this.__blocksById.filter(function(block){
                return block.isRendered();
            })
        },



        getOutOfBoundsRenderedBlocks: function(){
            var renderedBlocks             = this.getRenderedBlocks();
            var authorizedAndInBoundsBlocks = this.getAuthorizedAndInBoundsBlocks();
            var outOfBoundsRenderedBlocks  = _.difference(renderedBlocks, authorizedAndInBoundsBlocks);
            return outOfBoundsRenderedBlocks;
        },



        getAuthorizedAndInBoundsBlocks: function(){
            return this.getInBoundsBlocks().filter(function(block){
                return this.blockIdIsAuthorized(block._id);
            }.bind(this))
        },



        blockIdIsAuthorized: function(blockId){
            return this.stores.authStore.currentPlayer.unlockedBlocksIds.indexOf(blockId) !== -1;
        },



        generateEmptyBlocks: function(){
            var i = 1000;
            while(i--){
                var blockPos = PlanetGenerator.getXYFromUlamSpiralIndex(i);
                this.addBlock(new Block({
                    _id  : i,
                    pos  : blockPos,
                    game : this.game,
                }))
            }
        },



        getBlockByWorldPosXY: function(x, y){
            var blockX = Math.floor(x / constants.BLOCK_SIZE);
            var blockY = Math.floor(y / constants.BLOCK_SIZE);
            return this.getBlockByXY(blockX, blockY);
        },



        getAllShips: function(){
            var activeShips = [];
            _.forEach(this.__shipsById, function(ship){
                if(ship.destinationReached) return;
                activeShips.push(ship);
            })
            return activeShips;
        },



        replaceShipId: function(oldShipId, newShipId){
            var ship = this.__shipsById[oldShipId];
            delete this.__shipsById[oldShipId];
            this.__shipsById[newShipId] = ship;
            ship._id = newShipId;
        },



        addShip: function(ship){
            // Can happen when the ship travel between blocks because we
            // get the ships by a certain block, therefore no need to render
            // it again, as it's the exact same ship.
            if(this.hasShip(ship)) return;
            this.__shipsById[ship._id] = ship;
            this.onBlockUpdated.dispatch(ship.from.block);
        },



        hasShip: function(ship){
            return !!this.__shipsById[ship._id];
        },



        removeShipById: function(shipId){
            var ship = this.__shipsById[shipId];
            delete this.__shipsById[shipId];
            this.onBlockUpdated.dispatch(ship.to.block);
        },



        __addPlanet: function(planet){
            if(!planet) throw new Error('no planet')
            var planetId = planet._id;
            if(planetId === void 0) throw new Error('no planet id')
            if(this.__planetsById[planetId]) throw new Error('planet already added')
            this.__planetsById[planetId] = planet;
            if(!this.__planetsByBlockId[planet.block.id]){
                this.__planetsByBlockId[planet.block.id] = [];
            }
            this.__planetsByBlockId[planet.block.id].push(planet);
            planet.onChange = this.__onPlanetChangeBinded;
        },



        __onPlanetChange: function(planet, what){
            this.onBlockUpdated.dispatch(planet.block.id, what, planet);
        },



        setBlockPlanets: function(blockId, planets){
            var _this = this;
            planets.forEach(function(planet){
                _this.__addPlanet(planet)
            })
            this.onBlockUpdated.dispatch(blockId);
        },



        getPlanetsInBlockId: function(blockId){
            var planets = this.__planetsByBlockId[blockId];
            return planets ? planets.slice() : false;
        },



        getPlanetById: function(planetId){
            if(planetId === void 0) throw new Error('add a planet id')
            return this.__planetsById[planetId];
        },



        getAllPlanets: function(){
            return _.extend({}, this.__planetsById);
        },



        addBlock: function(block){
            this.__blocksById[block._id] = block;
            this.__blocksByPos[block.getPosAsString()] = block;
        },



        getBlockByXY: function(x, y){
            return this.__blocksByPos[Block.getPosXYAsString(x, y)];
        },



        getBlockByPosString: function(posString){
            return this.__blocksByPos[posString];
        },



        getBlockByPosObject: function(posObject){
            return this.getBlockByPosString(Block.getPosObjectAsString(posObject));
        },



        getBlockById: function(id){
            return this.__blocksById[id];
        },
    })





    return BlockStore;
});