aboutsummaryrefslogtreecommitdiff
path: root/space.js
blob: 89d2830b9ca384188aab4062dbe3736f006e87ed (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
// space.js, a full (not sparse data storage object) with some utilities.
// This includes from/to fetch, write, files, and ad-hoc strings. [DONE] [DONE] [DONE] [DONE] [DONE]
// It provides combination between Spaces. [DONE]
// It also gives a search utility and a utility to grab an arbitrary section [DONE] [DONE]
const fs = require('fs')

function chop(string, n){ // chops a string into n-sized chunks. Assumed to be perfect multiple
  arr = []
  while (string.length > 0){
    arr += string.slice(0,16);
  }
}
function replace(text, old, repl){ //replaces, in an array `text`, the instances of `old` with `repl`
  for (let i=0; i<text.length; i++){
    if (text[i] == old) text[i] = repl;
  }
  return text;
}

function Space(){ // CLASS
  this.data = []; //
  self = this;
  this.fromfetch = function(tiles, dimension){ //tiles is straight from fetch function, dimension is a quadruplet
    for (let y=dimension[0]; y<=dimension[2]; y++){
      for (let line=0; line<8; line++)
        this.data.push([]); // Adds lines
      for (let x=dimension[1]; x<=dimension[3]; x++){
        tilein(tiles[[y,x]],y-dimension[0]);
      }
    }

    function tilein(tile, tilerow){ //tile is one of the tiles from `tiles`, and tilerow is y-dimension[0]; helper function
      let incl = Object.keys(tile.properties.cell_props).map(linenum => linenum.parseInt()); // list of included lines in the content
      let cont = chop(tile.content,16);
      let read = 0; //line of cont to read
      for (let line=0; line<8; line++){
        curline = line+8*tilerow;
        if (incl.includes(line)){
          this.data[curline] += cont[read].split('');
          read++;
        } else {
          for (let i=0; i<16; i++) this.data[curline].push(' ');
        }
      }
    }
  }
  this.towrite = function(charoffset){ // Does no splitting or anything like that. Just returns a list of triplets for the write function
    let writes = [];
    console.log(this.data.length);
    for (line = 0; line < this.data.length; line++){
      console.log('boarlocueurgdaoecugd');
    }
    for (let line = 0; line < this.data.length; line++) for (let chr = 0; chr< this.data[line].length; chr++){
      writes.push([[Math.floor( (charoffset[0]+line)/8 ),Math.floor( (charoffset[1]+chr)/16 )],[ (charoffset[0]+line) % 8, (charoffset[1]+chr) % 16 ],this.data[line][chr]]);
    }
    return writes;
  }
  this.tofile = function(filename){
    fs.writeFile(filename,this.data.map(row => replace(row,'','&').join('').replace(/\\|&/g, '\\$&')).join('\n')+'\n',(err)=>{console.log(err);});
  };
  this.fromfile = function(filename){ //Reads an external file into internal data
    fs.readFile(filename, (err, data) => {
      if (err) throw err;
      self.adhoc(data);
    });
  }
  this.adhoc = function(text){
    this.data = text.split('\n').slice(0,-1).map(row => replace(row.replace(/\\(.)/g,'$1'.split(''),'&','')));
  }
  this.comb = function(other, func, offset){
    offsety = offset[0];
    offsetx = offset[1];
    for (let row = offset[0]; row<Math.max(other.data.length+offset[0],this.data.length); row++) for (let chr = offset[1]; chr<Math.max(otherlens.data[row].length+offset[1],this.data[row].length); chr++){
      if (row < 0)
        this.data.unshift([]);
      if (chr < 0)
        this.data[row].unshift('');
      if (row > this.data.length)
        this.data.push([]);
      if (chr > this.data[row].length)
        this.data[row].push('');
      this.data[row][chr] = func(this.data[row][chr], other.data[row][chr]);
    }
  }
  this.search = function(other){
    loc = [];
    for (let line=0; line<=this.data.length-other.data.length; line++) for (let chr=0; chr<=this.data[y].length-other.data[0].length; chr++){
      match = true;
      for (var y=0; y<other.data.length; y++) for (var x=0; x<other[y].data.length; x++){
        if (this.data[line+y][chr+x] != other.data[y][x]){
          match = false;
          break;
        }
      }
      if (match){
        loc = [line,chr];
        break;
      }
    }
    return loc;
  }
  this.subsection = function(range){ // range is a standard quadruplet
    newspace = new Space();
    for (let line=0; line<range[2]-range[0]; line++) for (let chr=0; chr<range[3]-range[1]; chr++){
      newspace.data[line][chr] = this.data[line+range[0]][line+range[1]];
    }
  }
}
    

exports.Space = Space