class TileMap extends TileGroup{ constructor(params){ if(params.tiles){ super(params.tiles) }else{ const tiles = [] for(let x = 0; x < params.width; x++){ for(let y = 0; y < params.height; y++){ tiles.push( new Tile({ x : x, y : y, type: 'empty' })) } } super(tiles) //Assumes origin is in upper left, moving down and to the right tiles.forEach(tile => { this.setNeighbors(tile) }) } this.width = params.width this.height = params.height } setNeighbors(tile){ tile.neighbors[0] = this.tile(tile.x,tile.y - 1) tile.neighbors[1] = this.tile(tile.x + 1,tile.y) tile.neighbors[2] = this.tile(tile.x,tile.y + 1) tile.neighbors[3] = this.tile(tile.x - 1,tile.y) } // Return a group or selection of tiles select(x,y,w,h,dir){ w = w || 1 h = h || 1 let ns = (dir & N)? N : S let ew = (dir & W)? W : E let result switch(ns|ew){ case (N|E): result = this.filter(d=>(d.x < x + w && d.x >= x && d.y > y - h && d.y <= y)); break case (S|E): result = this.filter(d=>(d.x < x + w && d.x >= x && d.y < y + h && d.y >= y)); break case (S|W): result = this.filter(d=>(d.x > x - w && d.x <= x && d.y < y + h && d.y >= y)); break case (N|W): result = this.filter(d=>(d.x > x - w && d.x <= x && d.y > y - h && d.y <= y)); break } return new TileMap({width: w, height:h, tiles: result}) } // Returns largest findGroup(x,y,type,dir,limitX,limitY){ let ns = (dir & N)? N : S let ew = (dir & W)? W : E let d1 = (ns == N)? 0 : 2 let d2 = (ew == W)? 3 : 1 let origin = this.tile(x,y) if(!origin || !origin.type || origin.type !== type) return false let height = 1 let width = 1 let maxSize = 0 let maxWidth = limitX || this.width let maxHeight = limitY || this.height let stack = [] let i = 0 let node = origin //Starting with the (x,y) we look south for matching types while(i < this.width){ if(node.neighbors[d1] && node.neighbors[d1].type == type && height < maxHeight){ height++ //height counter node = node.neighbors[d1] //set node to the southern neighbor for next check } else{ //after scanning vertically, update the maximum potential height maxHeight = Math.min(maxHeight, height) //store the groups by increasing width... stack.push({width: i+1, height: maxHeight, size: maxHeight * (i + 1)}) //Look to the east from the top, if the type matches, reset the origin to the next in the top row if(origin.neighbors[d2] && origin.neighbors[d2].type == type && width < maxWidth) { width++ origin = origin.neighbors[d2] node = origin height = 1 i++ } else { //we're done looking. break } } } const result = stack.sort((a,b)=>(b.size - a.size)).filter(t=>(t.width > 1 && t.height > 1))[0] if(!result){ return this.select(x,y,1,1) } switch(ns | ew){ case (N|E): return this.select(x,y-result.height + 1,result.width,result.height) case (N|W): return this.select(x-result.width + 1,y-result.height + 1,result.width,result.height) case (S|E): return this.select(x,y,result.width,result.height) case (S|W): return this.select(x-result.width + 1,y,result.width,result.height) } } place(tileGroup, ox, oy){ let newTiles = new TileGroup() for(let i = 0; i< tileGroup.length; i++){ let source = tileGroup[i] if(source.x + ox > this.width || source.y + oy > this.height || source.x + ox < 0, source.y + oy < 0){ return false } else{ let tile = new Tile({x: source.x + ox,y: source.y + oy, type: source.type}) for(let prop in source){ if(prop !== 'x' && prop !== 'y' && prop !== 'type')tile[prop] = source[prop] } newTiles.push(tile) } } newTiles.forEach(tile=>{ this.replace(tile) }) this.forEach(t=>this.setNeighbors(t)) newTiles.forEach(tile=>{ switch(tile.facing){ case N: if(tile.neighbors[0].type == 'empty')tile.neighbors[0].type = 'path'; break case E: if(tile.neighbors[1].type == 'empty')tile.neighbors[1].type = 'path'; break case S: if(tile.neighbors[2].type == 'empty')tile.neighbors[2].type = 'path'; break case W: if(tile.neighbors[3].type == 'empty')tile.neighbors[3].type = 'path'; break } }) return newTiles } walker (start, run, rise, total){ total = total || this.length run = run || 4 rise = rise || run let nodes = [{tile: this.tile(start.x,start.y)}] let group = new TileGroup() let totalCount = 0 const exit = () => (totalCount >= total) while ( !exit() ){ let tile = nodes[nodes.length - 1].tile group.push(tile) totalCount++ if( exit() ) break tile.type = 'HOLD' let choices = tile.neighbors.map((t,i)=>({tile:t, direction:i})) .filter(t=> { let tile = t.tile const dir = t.direction let distance = (dir == 0 || dir == 2)? rise : run if(tile && tile.type == 'empty' && tile.neighbors[dir]){ tile = tile.neighbors[dir] let step = 1 while(step < distance){ if(tile.type == 'empty' && tile.neighbors[dir] && tile.neighbors[dir].type == 'empty'){ tile = tile.neighbors[dir] step++ } else { return false } } return true } else { return false } }) if(choices.length > 0){ let pick = choices[ Math.floor(Math.random() * choices.length)] let step = 1 let distance = (pick.direction == 0 || pick.direction == 2)? rise : run while(step < distance){ group.push(pick.tile) pick.tile.type = 'HOLD' pick.tile = pick.tile.neighbors[pick.direction] totalCount++ if( exit() ) break step++ } nodes.push(pick) } else { break } } group.apply({type: 'empty'}) group.push(nodes[nodes.length - 1].tile) nodes = nodes.filter((n,i)=>{ if(i = nodes.length - 1){ return true } else if(nodes[i + 1] && nodes[i + 1].direction !== n.direction){ return true } else{ return false } }) return {nodes,group,total: totalCount} } save(){ return this.map(t=>({...t})) } load(group){ if(group.length !== this.length) return false this.forEach((t,i)=>{ for(let prop in group[i]){ if(group[i] && group[i][prop]){ t[prop] = group[i][prop] } else { delete t[prop] } } }) } }