Unityでノベルゲームを作ろう！(第5回：変数・論理演算(構文解析)編)

// 次の行へ移動
public void GoToTheNextLine()
{
  //次の行に移動する際のテキスト部分の初期化
  GameManager.Instance.mainTextController.NextLineInitial();
  
  GameManager.Instance.lineNumber++;
  string sentence = GetCurrentSentence();
  bool isStatement = IsStatement(sentence);

  GameManager.Instance.mainTextController.DisplayText(sentence, isStatement);
  if (isStatement)
  {
    GameManager.Instance.userScriptManager.ExecuteStatement(sentence);
  }
  //現在の文章が文章なのにノベルモードじゃなければ
  else if (GameManager.Instance.gameUpdateManager.getStateMode() != "novel")
  {
    GameManager.Instance.gameUpdateManager.ToggleToNovelMode();
  }
}

// 次の行へ移動したので初期化
public void NextLineInitial()
{
  _displayedSentenceLength = 0;
  _time = 0f;
  _mainTextObject.maxVisibleCharacters = 0;
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System.Text.RegularExpressions;

namespace NovelGame
{
  public class VariablesManager : MonoBehaviour
  {
    Dictionary<string, object> variables;
    private static int indexOfExpression;
    private static bool intFlag;

    void Awake()
    {
      //変数置き場
      variables = new Dictionary<string, object>();
      indexOfExpression = 0;
      intFlag = true;
    }
    
    /* メソッドを追加 */
  }
}

 //変数名から変数を取得する
 public object GetVariable(string variableName)
 {
   if (variables.ContainsKey(variableName))
   {
     return variables[variableName];
   }
   else
   {
     Debug.LogError("Variable not found: " + variableName);
     return null;
   }
 }

    // 文字列として与えられた式を変数を値に置換して文字列として返すメソッド
    public string ReplaceVariablesInExpression(string expression)
    {
      // 文字列中の"v[変数名]"のような部分を正規表現で取り出す
      var matches = Regex.Matches(expression, @"v\[(\w+)\]");
      foreach (Match match in matches)
      {
        string variableName = match.Groups[1].Value;
        object variableValue = GetVariable(variableName);
        expression = expression.Replace(match.Value, variableValue.ToString());
      }

      return expression;
    }

// 文字列として与えられた式を評価し、結果を返すメソッド
private string EvaluateCompareExpression(string expression)
{
 //v[変数名]になっているのを置き換える
  expression = ReplaceVariablesInExpression(expression);
  
   // 正規表現で比較演算子とその前後の部分を抽出する
  Regex regex = new Regex(@"(.*?)(==|!=|<=|>=|<|>)(.*)");
  Match match = regex.Match(expression);
  if (!match.Success)
  {
    // 式のフォーマットが不正の場合、エラーメッセージを出力して空文字を返す
    Debug.LogError("Invalid expression format: " + expression);
    return "";
  }

  // 左辺と右辺、比較演算子を取得
  string left = match.Groups[1].Value.Trim(); // 左辺
  string comparisonOperator = match.Groups[2].Value.Trim(); // 比較演算子
  string right = match.Groups[3].Value.Trim(); // 右辺

  // 左辺と右辺をオブジェクト型に設定（数値の場合は変換）
  object leftValue = left;
  object rightValue = right;

  // 左辺が数値に変換可能か確認し、変換する
  if (double.TryParse(left, out double leftDouble))
  {
    leftValue = leftDouble;
  }
  // 右辺が数値に変換可能か確認し、変換する
  if (double.TryParse(right, out double rightDouble))
  {
    rightValue = rightDouble;
  }

  // 比較演算子に基づいて比較を実行し、結果を返す
  switch (comparisonOperator)
  {
    case "==":
      return leftValue.Equals(rightValue) ? "T" : "F";
    case "!=":
      return (!leftValue.Equals(rightValue)) ? "T" : "F";
    case "<":
      return (Comparer.Default.Compare(leftValue, rightValue) < 0) ? "T" : "F";
    case "<=":
      return (Comparer.Default.Compare(leftValue, rightValue) <= 0) ? "T" : "F";
    case ">":
      return (Comparer.Default.Compare(leftValue, rightValue) > 0) ? "T" : "F";
    case ">=":
      return (Comparer.Default.Compare(leftValue, rightValue) >= 0) ? "T" : "F";
    default:
      // 不明な比較演算子の場合、エラーメッセージを出力して空文字を返す
      Debug.LogError("Invalid comparison operator: " + comparisonOperator);
      return "";
  }
}

private string ProcessCompareExpression(string expression)
{
  // expression 文字列に特別なマーカーを追加する
  expression = expression.Replace("NOT", "?_NOT?_");
  expression = expression.Replace("AND", "?_AND?_");
  expression = expression.Replace("OR", "?_OR?_");
  expression = expression.Replace("(", "?_(?_");
  expression = expression.Replace(")", "?_)?_");
  expression = expression.Replace("true", "?_true?_");
  expression = expression.Replace("false", "?_false?_");
  expression = expression.Replace("True", "?_true?_");
  expression = expression.Replace("False", "?_false?_");

  // マーカーを使用して文字列を分割する
  string[] parts = expression.Split(new[] { "?_" }, StringSplitOptions.RemoveEmptyEntries);

  int partsLength = parts.Length;
  string[] afterparts = new string[partsLength];
  for (int i = 0; i < partsLength; i++)
  {
    parts[i] = parts[i].Replace("?_", ""); // マーカーを削除
    afterparts[i] = EvaluateCompareExpression(parts[i]);
  }
  string afterExpression = "";
  foreach (string part in afterparts)
  {
    afterExpression += part;
  }
  return afterExpression;
}


// 文字列として与えられた式を評価し、結果を返すメソッド(追加部分をハイライトで表示)
private string EvaluateCompareExpression(string expression)
{
  expression = ReplaceVariablesInExpression(expression);

  if (expression == "(" || expression == ")")
  {
    return expression;
  }
  if (expression.ToLower() == "true")
  {
    return "T";
  }
  if (expression.ToLower() == "false")
  {
    return "F";
  }
  if (expression == "NOT")
  {
    return "!";
  }
  if (expression == "AND")
  {
    return "&";
  }
  if (expression == "OR")
  {
    return "|";
  }
  if (expression == " ")
  {
    return "";
  }

    // 正規表現で比較演算子とその前後の部分を抽出する
  Regex regex = new Regex(@"(.*?)(==|!=|<=|>=|<|>)(.*)");
  Match match = regex.Match(expression);
  if (!match.Success)
  {
    // 式のフォーマットが不正の場合、エラーメッセージを出力して空文字を返す
    Debug.LogError("Invalid expression format: " + expression);
    return "";
  }

  // 左辺と右辺、比較演算子を取得
  string left = match.Groups[1].Value.Trim(); // 左辺
  string comparisonOperator = match.Groups[2].Value.Trim(); // 比較演算子
  string right = match.Groups[3].Value.Trim(); // 右辺

  // 左辺と右辺をオブジェクト型に設定（数値の場合は変換）
  object leftValue = left;
  object rightValue = right;

  // 左辺が数値に変換可能か確認し、変換する
  if (double.TryParse(left, out double leftDouble))
  {
    leftValue = leftDouble;
  }
  // 右辺が数値に変換可能か確認し、変換する
  if (double.TryParse(right, out double rightDouble))
  {
    rightValue = rightDouble;
  }

  // 比較演算子に基づいて比較を実行し、結果を返す
  switch (comparisonOperator)
  {
    case "==":
      return leftValue.Equals(rightValue) ? "T" : "F";
    case "!=":
      return (!leftValue.Equals(rightValue)) ? "T" : "F";
    case "<":
      return (Comparer.Default.Compare(leftValue, rightValue) < 0) ? "T" : "F";
    case "<=":
      return (Comparer.Default.Compare(leftValue, rightValue) <= 0) ? "T" : "F";
    case ">":
      return (Comparer.Default.Compare(leftValue, rightValue) > 0) ? "T" : "F";
    case ">=":
      return (Comparer.Default.Compare(leftValue, rightValue) >= 0) ? "T" : "F";
    default:
      // 不明な比較演算子の場合、エラーメッセージを出力して空文字を返す
      Debug.LogError("Invalid comparison operator: " + comparisonOperator);
      return "";
  }
}

public bool EvaluateExpression(string s)
{
  indexOfExpression = 0;
  s = ProcessCompareExpression(s).Replace(" ", "");

  return ParseExpression(s);
}

// 解析および評価のメインメソッド
private bool ParseExpression(string s)
{
  bool val = ParseTerm(s);
  while (indexOfExpression < s.Length && s[indexOfExpression] == '|')
  {
    // OR演算子の場合
    indexOfExpression++;
    bool val2 = ParseTerm(s);
    val = val || val2;
  }
  return val;
}

// 項を解析して評価
private bool ParseTerm(string s)
{
  bool val = ParseFactor(s);
  while (indexOfExpression < s.Length && s[indexOfExpression] == '&')
  {
    // AND演算子の場合
    indexOfExpression++;
    bool val2 = ParseFactor(s);
    val = val && val2;
  }
  return val;
}

// 因子を解析して評価
private bool ParseFactor(string s)
{
  if (s[indexOfExpression] == '!')
  {
    // NOT演算子の場合、次の項を否定して返す
    indexOfExpression++;
    return !ParseFactor(s);
  }
  else if (s[indexOfExpression] == '(')
  {
    // 括弧の場合、内部の式を解析して評価
    indexOfExpression++;
    bool val = ParseExpression(s);
    indexOfExpression++; // Skip ')'
    return val;
  }
  else
  {
    // 変数の場合、その値を返す
    return ParseVariable(s);
  }
}

// 変数を解析して評価
private bool ParseVariable(string s)
{
  bool val = s[indexOfExpression] == 'T' || s[indexOfExpression] == 't'; // Assuming 'T' or 't' represents true and 'F' or 'f' represents false
  indexOfExpression++;
  return val;
}

/*変数設定系 */
public void SetVariable(string varName, string operand, string expression, string typeName)
{
  if (typeName == "bool" || typeName == "boolean")
  {
    variables[varName] = EvaluateExpression(expression);

  }
  else if (typeName == "int" || typeName == "float" || typeName == "number")
  {
    if (typeName == "int")
    {
      variables[varName] = Convert.ToInt32(expression);
    }
    else
    {
      variables[varName] = (float)Convert.ToDouble(expression);
      
    }
  }
  else
  {
    variables[varName] = expression;
  }
}

 // ステートメントを実行するメソッド
 public void ExecuteStatement(string sentence)
 {
   string[] words = sentence.Split(','); // 文章を単語に分割する

   // 単語によって処理を分岐する
   switch (words[2].ToLower())
   {
     /* 今まで実装したものはそのままで以下を追加 */
     
     case "setvar":
       string typeName = words[3];
       string varName = words[4];
       string operand = words[5];
       string expression = words[6];
       GameManager.Instance.variablesManager.SetVariable(varName, operand, expression, typeName);
       GoToTheNextLine();
       break;
       /* ここまで */
       
     default:
       break;
   }
 }