Don't make map view wider than necessary.

diff --git a/rogue_chat.html b/rogue_chat.html
index 5338e9daf323f1f8aef596ea5634407d2182d391..9f02d8dc790675dd29a7047ff8fae2d53d8ffdec 100644 (file)
--- a/rogue_chat.html
+++ b/rogue_chat.html
@@ -686,7 +686,6 @@ let tui = {
   log: [],
   input_prompt: '> ',
   input_lines: [],
   log: [],
   input_prompt: '> ',
   input_lines: [],

-  window_width: terminal.cols / 2,

   height_turn_line: 1,
   height_mode_line: 1,
   height_input: 1,
   height_turn_line: 1,
   height_mode_line: 1,
   height_input: 1,


@@ -739,6 +738,7 @@ let tui = {
   selectables: [],
   draw_face: false,
   init: function() {
   selectables: [],
   draw_face: false,
   init: function() {

+      this.reset_screen_size();

       this.mode_play.available_modes = ["chat", "study", "edit", "admin_enter",
                                         "command_thing", "take_thing", "drop_thing"]
       this.mode_play.available_actions = ["move", "teleport", "door", "consume",
       this.mode_play.available_modes = ["chat", "study", "edit", "admin_enter",
                                         "command_thing", "take_thing", "drop_thing"]
       this.mode_play.available_actions = ["move", "teleport", "door", "consume",


@@ -762,6 +762,10 @@ let tui = {
       this.height_header = this.height_turn_line + this.height_mode_line;
       this.init_keys();
   },
       this.height_header = this.height_turn_line + this.height_mode_line;
       this.init_keys();
   },

+  reset_screen_size: function() {
+      this.left_window_width = Math.min(52, terminal.cols / 2);
+      this.right_window_width = terminal.cols - tui.left_window_width;
+  },

   init_keys: function() {
     document.getElementById("move_table").hidden = true;
     this.keys = {};
   init_keys: function() {
     document.getElementById("move_table").hidden = true;
     this.keys = {};


@@ -997,7 +1001,7 @@ let tui = {
   recalc_input_lines: function() {
       if (this.mode.has_input_prompt) {
           let _ = null;
   recalc_input_lines: function() {
       if (this.mode.has_input_prompt) {
           let _ = null;

-          [this.input_lines, _] = this.msg_into_lines_of_width(this.input_prompt + this.inputEl.value + '█', this.window_width);
+          [this.input_lines, _] = this.msg_into_lines_of_width(this.input_prompt + this.inputEl.value + '█', this.right_window_width);

       } else {
           this.input_lines = [];
       }
       } else {
           this.input_lines = [];
       }


@@ -1212,7 +1216,7 @@ let tui = {
                 };
             };
         }
                 };
             };
         }

-        let window_center = [terminal.rows / 2, this.window_width / 2];
+        let window_center = [terminal.rows / 2, this.left_window_width / 2];

         let center_position = [game.player.position[0], game.player.position[1]];
         if (tui.mode.shows_info || tui.mode.name == 'control_tile_draw') {
             center_position = [explorer.position[0], explorer.position[1]];
         let center_position = [game.player.position[0], game.player.position[1]];
         if (tui.mode.shows_info || tui.mode.name == 'control_tile_draw') {
             center_position = [explorer.position[0], explorer.position[1]];


@@ -1229,7 +1233,7 @@ let tui = {
     let map_y = Math.max(0, this.offset[0]);
     let map_x = Math.max(0, this.offset[1]);
     for (; term_y < terminal.rows && map_y < this.map_lines.length; term_y++, map_y++) {
     let map_y = Math.max(0, this.offset[0]);
     let map_x = Math.max(0, this.offset[1]);
     for (; term_y < terminal.rows && map_y < this.map_lines.length; term_y++, map_y++) {

-        let to_draw = this.map_lines[map_y].slice(map_x, this.window_width + this.offset[1]);
+        let to_draw = this.map_lines[map_y].slice(map_x, this.left_window_width + this.offset[1]);

         terminal.write(term_y, term_x, to_draw);
     }
   },
         terminal.write(term_y, term_x, to_draw);
     }
   },


@@ -1239,7 +1243,7 @@ let tui = {
           this.draw_face = false;
           return;
       }
           this.draw_face = false;
           return;
       }

-      const start_x = tui.window_width - 10;
+      const start_x = tui.left_window_width - 10;

       function draw_body_part(body_part, end_y) {
           terminal.write(end_y - 3, start_x, '----------');
           terminal.write(end_y - 2, start_x, '| ' + body_part.slice(0, 6) + ' |');
       function draw_body_part(body_part, end_y) {
           terminal.write(end_y - 3, start_x, '----------');
           terminal.write(end_y - 2, start_x, '| ' + body_part.slice(0, 6) + ' |');


@@ -1264,10 +1268,10 @@ let tui = {
       if (this.mode.has_input_prompt) {
           help = 'enter /help for help';
       }
       if (this.mode.has_input_prompt) {
           help = 'enter /help for help';
       }

-      terminal.write(1, this.window_width, 'MODE: ' + this.mode.short_desc + ' – ' + help);
+      terminal.write(1, this.left_window_width, 'MODE: ' + this.mode.short_desc + ' – ' + help);

   },
   draw_stats_line: function(n) {
   },
   draw_stats_line: function(n) {

-      terminal.write(0, this.window_width,
+      terminal.write(0, this.left_window_width,

                      'ENERGY: ' + game.energy +
                      ' BLADDER: ' + game.bladder_pressure);
   },
                      'ENERGY: ' + game.energy +
                      ' BLADDER: ' + game.bladder_pressure);
   },


@@ -1277,7 +1281,7 @@ let tui = {
       let y_offset_in_log = 0;
       for (let line of this.log) {
           let [new_lines, link_data] = this.msg_into_lines_of_width(line,
       let y_offset_in_log = 0;
       for (let line of this.log) {
           let [new_lines, link_data] = this.msg_into_lines_of_width(line,

-                                                                    this.window_width)
+                                                                    this.right_window_width)

           log_display_lines = log_display_lines.concat(new_lines);
           for (const y in link_data) {
               const rel_y = y_offset_in_log + parseInt(y);
           log_display_lines = log_display_lines.concat(new_lines);
           for (const y in link_data) {
               const rel_y = y_offset_in_log + parseInt(y);


@@ -1292,7 +1296,7 @@ let tui = {
       for (let y = terminal.rows - 1 - this.height_input;
            y >= this.height_header && i >= 0;
            y--, i--) {
       for (let y = terminal.rows - 1 - this.height_input;
            y >= this.height_header && i >= 0;
            y--, i--) {

-          terminal.write(y, this.window_width, log_display_lines[i]);
+          terminal.write(y, this.left_window_width, log_display_lines[i]);

       }
       for (const key of Object.keys(log_links)) {
           if (parseInt(key) <= i) {
       }
       for (const key of Object.keys(log_links)) {
           if (parseInt(key) <= i) {


@@ -1300,13 +1304,13 @@ let tui = {
           }
       }
       let offset = [terminal.rows - this.height_input - log_display_lines.length,
           }
       }
       let offset = [terminal.rows - this.height_input - log_display_lines.length,

-                    this.window_width];
+                    this.left_window_width];

       this.offset_links(offset, log_links);
   },
   draw_info: function() {
       const info = "MAP VIEW: " + tui.map_mode + "\n" + explorer.get_info();
       this.offset_links(offset, log_links);
   },
   draw_info: function() {
       const info = "MAP VIEW: " + tui.map_mode + "\n" + explorer.get_info();

-      let [lines, link_data] = this.msg_into_lines_of_width(info, this.window_width);
-      let offset = [this.height_header, this.window_width];
+      let [lines, link_data] = this.msg_into_lines_of_width(info, this.right_window_width);
+      let offset = [this.height_header, this.left_window_width];

       for (let y = offset[0], i = 0; y < terminal.rows && i < lines.length; y++, i++) {
         terminal.write(y, offset[1], lines[i]);
       }
       for (let y = offset[0], i = 0; y < terminal.rows && i < lines.length; y++, i++) {
         terminal.write(y, offset[1], lines[i]);
       }


@@ -1315,7 +1319,7 @@ let tui = {
   draw_input: function() {
     if (this.mode.has_input_prompt) {
         for (let y = terminal.rows - this.height_input, i = 0; i < this.input_lines.length; y++, i++) {
   draw_input: function() {
     if (this.mode.has_input_prompt) {
         for (let y = terminal.rows - this.height_input, i = 0; i < this.input_lines.length; y++, i++) {

-            terminal.write(y, this.window_width, this.input_lines[i]);
+            terminal.write(y, this.left_window_width, this.input_lines[i]);

         }
     }
   },
         }
     }
   },


@@ -1346,12 +1350,18 @@ let tui = {
       }
       content += this.mode.list_available_modes();
       let start_x = 0;
       }
       content += this.mode.list_available_modes();
       let start_x = 0;

+      let lines = [];
+      let _ = undefined;

       if (!this.mode.has_input_prompt) {
       if (!this.mode.has_input_prompt) {

-          start_x = this.window_width;
+          start_x = this.left_window_width;

           this.draw_links = false;
           this.draw_links = false;

+          terminal.drawBox(0, start_x, terminal.rows, this.right_window_width);
+          [lines, _] = this.msg_into_lines_of_width(content, this.right_window_width);
+      } else {
+          start_x = 0;
+          terminal.drawBox(0, start_x, terminal.rows, this.left_window_width);
+          [lines, _] = this.msg_into_lines_of_width(content, this.left_window_width);

       }
       }

-      terminal.drawBox(0, start_x, terminal.rows, this.window_width);
-      let [lines, _] = this.msg_into_lines_of_width(content, this.window_width);

       for (let y = 0, i = 0; y < terminal.rows && i < lines.length; y++, i++) {
           terminal.write(y, start_x, lines[i]);
       }
       for (let y = 0, i = 0; y < terminal.rows && i < lines.length; y++, i++) {
           terminal.write(y, start_x, lines[i]);
       }


@@ -1597,7 +1607,6 @@ let explorer = {
             if (t.design) {
                 const line_length = t.design[0][1];
                 info += '-'.repeat(line_length + 4) + '\n';
             if (t.design) {
                 const line_length = t.design[0][1];
                 info += '-'.repeat(line_length + 4) + '\n';

-                console.log(line_length)

                 let lines = ['']
                 if (line_length > 0) {
                     const regexp = RegExp('.{1,' + line_length + '}', 'g');
                 let lines = ['']
                 if (line_length > 0) {
                     const regexp = RegExp('.{1,' + line_length + '}', 'g');


@@ -1632,7 +1641,7 @@ let explorer = {
 
 tui.inputEl.addEventListener('input', (event) => {
     if (tui.mode.has_input_prompt) {
 
 tui.inputEl.addEventListener('input', (event) => {
     if (tui.mode.has_input_prompt) {

-        let max_length = tui.window_width * terminal.rows - tui.input_prompt.length;
+        let max_length = tui.right_window_width * terminal.rows - tui.input_prompt.length;

         if (tui.inputEl.value.length > max_length) {
             tui.inputEl.value = tui.inputEl.value.slice(0, max_length);
         };
         if (tui.inputEl.value.length > max_length) {
             tui.inputEl.value = tui.inputEl.value.slice(0, max_length);
         };


@@ -1837,7 +1846,7 @@ cols_selector.addEventListener('input', function() {
     }
     window.localStorage.setItem(cols_selector.id, cols_selector.value);
     terminal.initialize();
     }
     window.localStorage.setItem(cols_selector.id, cols_selector.value);
     terminal.initialize();

-    tui.window_width = terminal.cols / 2,
+    tui.reset_screen_size();

     tui.full_refresh();
 }, false);
 for (let key_selector of key_selectors) {
     tui.full_refresh();
 }, false);
 for (let key_selector of key_selectors) {

diff --git a/rogue_chat_curses.py b/rogue_chat_curses.py
index fd28049072a3fc62e9a310872ef242b935f91e68..65d5a339c013558cde62127d4ba8264f6d8b16f7 100755 (executable)
--- a/rogue_chat_curses.py
+++ b/rogue_chat_curses.py
@@ -940,7 +940,8 @@ class TUI:
             self.size = YX(*stdscr.getmaxyx())
             self.size = self.size - YX(self.size.y % 4, 0)
             self.size = self.size - YX(0, self.size.x % 4)
             self.size = YX(*stdscr.getmaxyx())
             self.size = self.size - YX(self.size.y % 4, 0)
             self.size = self.size - YX(0, self.size.x % 4)

-            self.window_width = int(self.size.x / 2)
+            self.left_window_width = min(52, int(self.size.x / 2))
+            self.right_window_width = self.size.x - self.left_window_width

 
         def recalc_input_lines():
             if not self.mode.has_input_prompt:
 
         def recalc_input_lines():
             if not self.mode.has_input_prompt:


@@ -948,7 +949,7 @@ class TUI:
             else:
                 self.input_lines = msg_into_lines_of_width(input_prompt
                                                            + self.input_ + '█',
             else:
                 self.input_lines = msg_into_lines_of_width(input_prompt
                                                            + self.input_ + '█',

-                                                           self.window_width)
+                                                           self.right_window_width)

 
         def move_explorer(direction):
             target = self.game.map_geometry.move_yx(self.explorer, direction)
 
         def move_explorer(direction):
             target = self.game.map_geometry.move_yx(self.explorer, direction)


@@ -963,41 +964,41 @@ class TUI:
         def draw_history():
             lines = []
             for line in self.log:
         def draw_history():
             lines = []
             for line in self.log:

-                lines += msg_into_lines_of_width(line, self.window_width)
+                lines += msg_into_lines_of_width(line, self.right_window_width)

             lines.reverse()
             height_header = 2
             max_y = self.size.y - len(self.input_lines)
             for i in range(len(lines)):
                 if (i >= max_y - height_header):
                     break
             lines.reverse()
             height_header = 2
             max_y = self.size.y - len(self.input_lines)
             for i in range(len(lines)):
                 if (i >= max_y - height_header):
                     break

-                safe_addstr(max_y - i - 1, self.window_width, lines[i])
+                safe_addstr(max_y - i - 1, self.left_window_width, lines[i])

 
         def draw_info():
             info = 'MAP VIEW: %s\n%s' % (self.map_mode, self.get_info())
 
         def draw_info():
             info = 'MAP VIEW: %s\n%s' % (self.map_mode, self.get_info())

-            lines = msg_into_lines_of_width(info, self.window_width)
+            lines = msg_into_lines_of_width(info, self.right_window_width)

             height_header = 2
             for i in range(len(lines)):
                 y = height_header + i
                 if y >= self.size.y - len(self.input_lines):
                     break
             height_header = 2
             for i in range(len(lines)):
                 y = height_header + i
                 if y >= self.size.y - len(self.input_lines):
                     break

-                safe_addstr(y, self.window_width, lines[i])
+                safe_addstr(y, self.left_window_width, lines[i])

 
         def draw_input():
             y = self.size.y - len(self.input_lines)
             for i in range(len(self.input_lines)):
 
         def draw_input():
             y = self.size.y - len(self.input_lines)
             for i in range(len(self.input_lines)):

-                safe_addstr(y, self.window_width, self.input_lines[i])
+                safe_addstr(y, self.left_window_width, self.input_lines[i])

                 y += 1
 
         def draw_stats():
             stats = 'ENERGY: %s BLADDER: %s' % (self.game.energy,
                                                 self.game.bladder_pressure)
                 y += 1
 
         def draw_stats():
             stats = 'ENERGY: %s BLADDER: %s' % (self.game.energy,
                                                 self.game.bladder_pressure)

-            safe_addstr(0, self.window_width, stats)
+            safe_addstr(0, self.left_window_width, stats)

 
         def draw_mode():
             help = "hit [%s] for help" % self.keys['help']
             if self.mode.has_input_prompt:
                 help = "enter /help for help"
 
         def draw_mode():
             help = "hit [%s] for help" % self.keys['help']
             if self.mode.has_input_prompt:
                 help = "enter /help for help"

-            safe_addstr(1, self.window_width,
+            safe_addstr(1, self.left_window_width,

                         'MODE: %s – %s' % (self.mode.short_desc, help))
 
         def draw_map():
                         'MODE: %s – %s' % (self.mode.short_desc, help))
 
         def draw_map():


@@ -1054,7 +1055,7 @@ class TUI:
                     for line in map_lines_split:
                         self.map_lines += [''.join(line)]
                 window_center = YX(int(self.size.y / 2),
                     for line in map_lines_split:
                         self.map_lines += [''.join(line)]
                 window_center = YX(int(self.size.y / 2),

-                                   int(self.window_width / 2))
+                                   int(self.left_window_width / 2))

                 center = self.game.player.position
                 if self.mode.shows_info or self.mode.name == 'control_tile_draw':
                     center = self.explorer
                 center = self.game.player.position
                 if self.mode.shows_info or self.mode.name == 'control_tile_draw':
                     center = self.explorer


@@ -1067,7 +1068,7 @@ class TUI:
             map_y = max(0, self.offset.y)
             map_x = max(0, self.offset.x)
             while term_y < self.size.y and map_y < len(self.map_lines):
             map_y = max(0, self.offset.y)
             map_x = max(0, self.offset.x)
             while term_y < self.size.y and map_y < len(self.map_lines):

-                to_draw = self.map_lines[map_y][map_x:self.window_width + self.offset.x]
+                to_draw = self.map_lines[map_y][map_x:self.left_window_width + self.offset.x]

                 safe_addstr(term_y, term_x, to_draw)
                 term_y += 1
                 map_y += 1
                 safe_addstr(term_y, term_x, to_draw)
                 term_y += 1
                 map_y += 1


@@ -1078,7 +1079,7 @@ class TUI:
                 self.draw_face = False
                 return
 
                 self.draw_face = False
                 return
 

-            start_x = self.window_width - 10
+            start_x = self.left_window_width - 10

             def draw_body_part(body_part, end_y):
                 safe_addstr(end_y - 3, start_x, '----------')
                 safe_addstr(end_y - 2, start_x, '| ' + body_part[0:6] + ' |')
             def draw_body_part(body_part, end_y):
                 safe_addstr(end_y - 3, start_x, '----------')
                 safe_addstr(end_y - 2, start_x, '| ' + body_part[0:6] + ' |')


@@ -1116,16 +1117,16 @@ class TUI:
             content += self.mode.list_available_modes(self)
             for i in range(self.size.y):
                 safe_addstr(i,
             content += self.mode.list_available_modes(self)
             for i in range(self.size.y):
                 safe_addstr(i,

-                            self.window_width * (not self.mode.has_input_prompt),
-                            ' ' * self.window_width)
+                            self.left_window_width * (not self.mode.has_input_prompt),
+                            ' ' * self.left_window_width)

             lines = []
             for line in content.split('\n'):
             lines = []
             for line in content.split('\n'):

-                lines += msg_into_lines_of_width(line, self.window_width)
+                lines += msg_into_lines_of_width(line, self.right_window_width)

             for i in range(len(lines)):
                 if i >= self.size.y:
                     break
                 safe_addstr(i,
             for i in range(len(lines)):
                 if i >= self.size.y:
                     break
                 safe_addstr(i,

-                            self.window_width * (not self.mode.has_input_prompt),
+                            self.left_window_width * (not self.mode.has_input_prompt),

                             lines[i])
 
         def draw_screen():
                             lines[i])
 
         def draw_screen():


@@ -1307,7 +1308,7 @@ class TUI:
                 self.restore_input_values()
             elif self.mode.has_input_prompt and key != '\n':  # Return key
                 self.input_ += key
                 self.restore_input_values()
             elif self.mode.has_input_prompt and key != '\n':  # Return key
                 self.input_ += key

-                max_length = self.window_width * self.size.y - len(input_prompt) - 1
+                max_length = self.right_window_width * self.size.y - len(input_prompt) - 1

                 if len(self.input_) > max_length:
                     self.input_ = self.input_[:max_length]
             elif key == self.keys['help'] and not self.mode.is_single_char_entry:
                 if len(self.input_) > max_length:
                     self.input_ = self.input_[:max_length]
             elif key == self.keys['help'] and not self.mode.is_single_char_entry: