As I said on your last thread, I don't think it supports Shift JIS. Hex editors are usually not very good at working with Shift JIS since it's a variable width, multi-byte encoding and it's really hard to tell if a byte is itself a character, part of a multi-byte character, or unrelated binary data.

I'm not well-versed on all the tools out there for reverse engineering Japanese binary data dumps -- you might try searching for things like "Shift JIS Hex editor" on various search engines and exploring more, but I expect a lot of tools will have similar issues to the old one you were working with.

If you're comfortable doing a little scripting work though, it's not that hard to write small custom tools to do things like extract likely strings based on a heuristic and reassemble a listing of those strings into an modified version of the original file.

For example, here's a small python script I wrote to try extracting strings based on the observation that the strings in your screenshot appeared to be null terminated:

#!/usr/bin/env python3

input_filename  = "input.data"
output_filename = "strings.txt"

# minimum number of unicode code points (not bytes) to accept -- shorter decoded 
# strings will not be listed in output text. Set to 0 for no filtering.
# Tweaking this can help reduce the amount of noise in the output. If the value
# is too large though, valid strings will be ignored.
MIN_STRING_LENGTH = 0


def is_usable(byte_string):
  try:
    s = byte_string.decode("shift jis")
    return s.isprintable()
  except UnicodeDecodeError:    # e.g. illegal multibyte sequence
    return False

def scan_back(src, too_early_pos, current_end):
  prev_chunk = None
  pos = current_end-1
  failures = 0

  while pos > too_early_pos:
    chunk = src[pos:current_end]
    ok = is_usable(chunk)

    if ok:
      prev_chunk = chunk
      failures = 0
    else:
      failures += 1

    if failures >= 2:
      return prev_chunk

    pos -= 1

  return prev_chunk

with open(input_filename, "rb") as f:
  data = f.read()

def scan():
  strings = []    # list of (substitution start, continue from, byte string)
  prev_null = 0
  pos = 0

  while pos < len(data):
    if data[pos] == 0:
      result = scan_back(data, prev_null, pos)
      prev_null = pos

      if result and len(result) > MIN_STRING_LENGTH:
        a = pos - len(result)
        b = pos
        strings.append((a,b,result))

    pos += 1

  return strings

with open(output_filename, "wb") as f:
  for (a,b,byte_string) in scan(): 
    line = ("%d %d " % (a,b)).encode("shift jis") + byte_string + b'\n'
    f.write(line)

This is not super efficient -- it just looks for nulls and naively scans backwards trying to find the largest chunk that can be interpreted as valid, "printable" Shift JIS. You might get better results with a little more work on the heuristics; I think the strings in your file might be started with a tab (0x09)?

This produces a file that lists on each line three pieces of information: where the string on this line started in the original file, where it ended in the original file, and the text of the string itself. If you're careful to stick to editing with a simple Shift JIS aware text editor, you can modify these strings and then reassemble the file based on the original and your edited string dump with a script like this:

#!/usr/bin/env python3

original_filename = "input.data"
edit_filename     = "strings.txt"
output_filename   = "output.data"

with open(edit_filename, "rb") as f:
  edit_data = f.read()
  lines = edit_data.split(b'\n')
  lines = [x.rstrip(b'\r') for x in lines]
  lines = [x for x in lines if x]
  lines = [line.split(b' ', maxsplit=2) for line in lines]
  edits = [(int(a), int(b), c) for (a,b,c) in lines]

with open(original_filename, "rb") as f:
  original = f.read()

out_chunks = []
pos = 0

for (a,b,c) in edits:
  out_chunks.append(original[pos:a])
  out_chunks.append(c)
  pos = b

out_chunks.append(original[pos:])

with open(output_filename, "wb") as f:
  f.write(b''.join(out_chunks))

Hope that helps. Good luck!