JAVAにて９×９の盤面のマス目にに順番をつける

Question

前提・実現したいこと

まず、私はプログラミングを独学ではじめ、なかなか理解できず、とにかく触って慣れていこうと思い、ネット上の様々な情報を切り貼りし、
現在、昔 段ボールで作ったすごろくゲームの再現に取り組んでいます。
そこで9×9のマス目の盤面において、以下のようにマスに番号を付け、１から、サイコロででた目ｘだけ進んで１＋ｘにたどり着くという状況を作りたいです。
｜７３｜７４｜７５｜７６｜７７｜７８｜７９｜８０｜８１｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜７２｜４３｜４４｜４５｜４６｜４７｜４８｜４９｜５０｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜７１｜４２｜２１｜２２｜２３｜２４｜２５｜２６｜５１｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜７０｜４１｜２０｜　７｜　８｜　９｜１０｜２７｜５２｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜６９｜４０｜１９｜　６｜　１｜　２｜１１｜２８｜５３｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜６８｜３９｜１８｜　５｜　４｜　３｜１２｜２９｜５４｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜６７｜３８｜１７｜１６｜１５｜１４｜１３｜３０｜５５｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜６６｜３７｜３６｜３５｜３４｜３３｜３２｜３１｜５６｜
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
｜６５｜６４｜６３｜６２｜６１｜６０｜５９｜５８｜５７｜

発生している問題・エラーメッセージ

エラーはありません。ですが上記の通り全くの初心者であり、できる限りネットを駆使して検索をかけたものの答えが出ず、どうすれば思い道理になるのかが全く見当がつかないため、見識のある方々に伺おうと思った次第です。
具体的には下記の(250,300,50,50)を一番目として四角にそれぞれ番号を付けたいです。

該当のソースコード

public class C{
	public static void main(String[] args) {
		GameWindow gw = new GameWindow("マス目",550,600);
		gw.add(new DrawCanvas());
		gw.setVisible(true);
	}
}
 
class DrawCanvas extends JPanel{
		g.drawRect(250,300,50,50);//四角１
		g.drawRect(300,300,50,50);//四角２
		g.drawRect(300,350,50,50);//四角３
                    .
                    .
                    .
                    .
}

試したこと

マス目の座標を変数で置き、マス目に番号を振るクラスを別で設けようとしたり、ネットで情報を探りましたが、有効な手段は見つけられませんでした。

補足情報（FW/ツールのバージョンなど）

ツールのバージョンは把握できていませんが、jdk16のことかと思います

Comments

[dodox86]

tetatailへの質問投稿は初めてとお見受けしてのコメントです。まず、コードはそのまま貼り付けてしまうと強力に見づらく、読みづらく、それだけで閲覧、回答する方々は読む気が失せるものです。teratailでは「マークダウン記法」と言うものが使えるので、それを使ってください。

[質問するときのヒント] https://teratail.com/help/question-tips
[3-8. テンプレートを利用しましょう] https://teratail.com/help/question-tips#questionTips3-8

具体的には例えばJavaのコードなら```Java～```で括ります。
```Java
public class Main {
// Hoge
}
```

これをちゃんとすれば回答が付きやすくなります。

現状の質問内容は読みづらいのでご提示のコードは読んでいませんが（＜こう思う方々は私だけではないと思います）　9x9の盤面なら9行9列で表せられるので、行と列を意識すれば比較的簡単に直列の番号を与えることができます。ネットを検索しまくって答えを得るのも良いですが、自分でも考えてみましょう。

[hoshi-takanori]

力作ですね。ですが、いきなり 9x9 を扱うのは辛そうなので、まず 3x3 か 5x5 くらいの単純なやつ (または一直線のほうがいいかも…) で練習した方が良い気がします。

また、if(b!=5&c!=5) { のところですが、2 つの条件を「かつ」で結ぶのは & じゃなくて && ですね。
https://eng-entrance.com/java-cal-case

[swordone]

@hoshi-takanori
いや、&でも「かつ」で結ばれます。短絡評価か否かの違いです。

[jimbe]

力作というか力業となってしまうのは最初は仕方無い所でしょうね。(^_^;

[yuki_java]

ソースコード全文写していたものを一部だけにしました。また、＆の部分は自分のノートを見返したときに「AかつB」は＆＆だと書いていたので修正しました。
私自身も初心者ながらこれはなかなかの力業だなと思うものです。

[jimbe]

ちゃんとマークダウンになりましたので、これなら必要に応じて開いたり閉じたり出来ますから、多少長くても大丈夫ですよ d^^

Answer 1

一気に編集されすぎて意味が分からないうえ文法エラーになっているので、当初のコードだとして回答します（長すぎるのもあれですが、短すぎはもっとイヤですね）

yuki_javaさん自身も力技だと感じておられるようですが、どうせならスマートに解決したいですよね。

今回のポイントは明らかに渦巻ですよね？
課題か何かで「渦巻の数字を出力せよ」みたいなものもありそうですし、ヒントがないか検索してみます。

「java 数字 渦巻」で検索したらこちらが出ました。
２次元配列　に数値を並べる

英語も直訳で「java number swirl」としたらこちらが出ました（Spiralなんですね～^^;
How To Create Spiral Of Numbers (Spiral Matrix) In Java?

どちらも何をやっているかさっぱりわかりませんが、今回はxyの並びが好みな後者にしました^^;
メソッドに切り出し、コンソール出力で動作確認をしてみましょう。

public class Sample {
    public static void main(String[] args) {
        int[][] array = getSpiralMatrix(5);

        for (int[] a : array) {
            for (int i : a) {
                System.out.printf("%3d", i);
            }
            System.out.println();
        }
    }

    // [How To Create Spiral Of Numbers (Spiral Matrix) In Java?](https://javaconceptoftheday.com/how-to-create-spiral-of-numbers-matrix-in-java/)
    private static int[][] getSpiralMatrix(int n) {
        int[][] spiral = new int[n][n];
        int value = 1;
        int minCol = 0;
        int minRow = 0;
        int maxCol = n - 1;
        int maxRow = n - 1;

        while (value <= n * n) {
            for (int i = minCol; i <= maxCol; i++) {
                spiral[minRow][i] = value++;
            }
            for (int i = minRow + 1; i <= maxRow; i++) {
                spiral[i][maxCol] = value++;
            }
            for (int i = maxCol - 1; i >= minCol; i--) {
                spiral[maxRow][i] = value++;
            }
            for (int i = maxRow - 1; i >= minRow + 1; i--) {
                spiral[i][minCol] = value++;
            }
            minCol++; minRow++; maxCol--; maxRow--;
        }

        return spiral;
    }
}

  1  2  3  4  5
 16 17 18 19  6
 15 24 25 20  7
 14 23 22 21  8
 13 12 11 10  9

左上から時計回りに数字が増えていくようですね。

真ん中を１にするのは簡単ですね。そのうえで左右反転すればよさそうです。
当然ググります（日本語ではいまいちだったので英語）
java 2nd dimension array reverse - Google 検索
java - Reverse the rows of a 2d array - Stack Overflow

public class Sample {
    public static void main(String[] args) {
        int[][] array = getSpiralMatrix(5);

        // 真ん中始まり
        for (int y = 0; y < array.length; y++) {
            for (int x = 0; x < array[y].length; x++) {
                array[y][x] = (5 * 5 + 1) - array[y][x];
            }
        }

        // 左右反転
        // [java - Reverse the rows of a 2d array - Stack Overflow](https://stackoverflow.com/questions/21920939/reverse-the-rows-of-a-2d-array)
        for (int j = 0; j < array.length; j++) {
            for (int i = 0; i < array[j].length / 2; i++) {
                int temp = array[j][i];
                array[j][i] = array[j][array[j].length - i - 1];
                array[j][array[j].length - i - 1] = temp;
            }
        }

        for (int[] a : array) {
            for (int i : a) {
                System.out.printf("%3d", i);
            }
            System.out.println();
        }
    }

    private static int[][] getSpiralMatrix(int n) { /* 同じなので省略 */ }
}

 21 22 23 24 25
 20  7  8  9 10
 19  6  1  2 11
 18  5  4  3 12
 17 16 15 14 13

---

上記を超ふまえたうえで、GUIにするとこうなりました^^;
この２次元配列を種にして（xyや番号はわかっている）、マスのクラス（Cell）を生成します。

あくまでアウトラインですが、部品は揃ってると思いますので参考にしていただけたらと思います^^

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Stroke;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class GameWindow extends JFrame {
    public static void main(String[] args) {
        new GameWindow().setVisible(true);
    }

    public GameWindow() {
        DrawCanvas panel = new DrawCanvas();
//        setSize(550, 600); // JFrame のサイズはタイトルバー・枠も含むので微妙にずれる
        panel.setPreferredSize(new Dimension(550, 600)); // 中身の推奨サイズを設定
        add(panel);
        pack();

        setResizable(false);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
}

class Cell {
    int no;
    Rectangle rect;
    Color color;

    Cell(int no, Rectangle rect, Color color) {
        this.no = no;
        this.rect = rect;
        this.color = color;
    }

    void draw(Graphics2D g2) {
        g2.setColor(color);
        g2.fill(rect);
        g2.setColor(Color.BLACK);
        g2.draw(rect);
        g2.drawString(String.valueOf(no), rect.x + 5, rect.y + 15);
    }
}

class DrawCanvas extends JPanel {
    private final int[][] array = getSpiralMatrix(9);
    private final ArrayList<Cell> cells = new ArrayList<>();

    private int current = 1;

    DrawCanvas() {
        initialize();

        JButton go = new JButton("go");
        go.addActionListener(e -> { current++; repaint(); });
        add(go);

        JButton back = new JButton("back");
        back.addActionListener(e -> { current--; repaint(); });
        add(back);

        JButton rotation90 = new JButton("rotation90");
        rotation90.addActionListener(e -> { rotation(); repaint(); });
        add(rotation90);

        JButton rotation180 = new JButton("rotation180");
        rotation180.addActionListener(e -> { rotation(); rotation(); repaint(); });
        add(rotation180);
    }

    private void initialize() {
        for (int y = 0; y < array.length; y++) {
            for (int x = 0; x < array[y].length; x++) {
                array[y][x] = (array.length * array.length + 1) - array[y][x];
            }
        }
        // [java - Reverse the rows of a 2d array - Stack Overflow](https://stackoverflow.com/questions/21920939/reverse-the-rows-of-a-2d-array)
        for (int j = 0; j < array.length; j++) {
            for (int i = 0; i < array[j].length / 2; i++) {
                int temp = array[j][i];
                array[j][i] = array[j][array[j].length - i - 1];
                array[j][array[j].length - i - 1] = temp;
            }
        }

        // array を種にして Cell のリストを作る
        Color c = new Color(0, 170, 0);
        for (int y = 0; y < array.length; y++) {
            for (int x = 0; x < array[y].length; x++) {
                Rectangle r = new Rectangle(x * 50 + 50, y * 50 + 100, 50, 50);
                cells.add(new Cell(array[y][x], r, c));
            }
        }
        // 番号順に並び変えれば点線を描きやすい
        cells.sort((a, b) -> a.no - b.no);
    }

    private static final BasicStroke dashed = new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1, new float[]{ 5 }, 0);

    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        Graphics2D g2 = (Graphics2D) g;
        Stroke oldStroke = g2.getStroke();

        Cell before = null;
        for (Cell cell : cells) {
            cell.draw(g2);

            // 前のセルとの間に点線を引く
            if (before != null) {
                g2.setStroke(dashed);
                int x1 = before.rect.x + before.rect.width / 2;
                int y1 = before.rect.y + before.rect.height / 2;
                int x2 = cell.rect.x + cell.rect.width / 2;
                int y2 = cell.rect.y + cell.rect.height / 2;
                g2.drawLine(x1, y1, x2, y2);
                g2.setStroke(oldStroke);
            }
            before = cell;

            if (current == cell.no) {
                g2.setColor(Color.RED);
                Rectangle rect = cell.rect.getBounds();
                rect.grow(-15, -15); // 一回り小さい四角に
                g2.fill(rect);
            }
        }
    }

    // current を右９０度回転 ２次元配列の回転を応用（正方形のみ）
    private void rotation() {
        for (int j = 0; j < array.length; j++) {
            for (int i = 0; i < array[j].length; i++) {
                if (current == array[j][i]) {
                    current = array[i][array.length - j - 1];
                    return;
                }
            }
        }
    }

    // [How To Create Spiral Of Numbers (Spiral Matrix) In Java?](https://javaconceptoftheday.com/how-to-create-spiral-of-numbers-matrix-in-java/)
    private int[][] getSpiralMatrix(int n) {
        int[][] spiral = new int[n][n];
        int value = 1;
        int minCol = 0;
        int minRow = 0;
        int maxCol = n - 1;
        int maxRow = n - 1;

        while (value <= n * n) {
            for (int i = minCol; i <= maxCol; i++) {
                spiral[minRow][i] = value++;
            }
            for (int i = minRow + 1; i <= maxRow; i++) {
                spiral[i][maxCol] = value++;
            }
            for (int i = maxCol - 1; i >= minCol; i--) {
                spiral[maxRow][i] = value++;
            }
            for (int i = maxRow - 1; i >= minRow + 1; i--) {
                spiral[i][minCol] = value++;
            }
            minCol++; minRow++; maxCol--; maxRow--;
        }

        return spiral;
    }
}

Comments

[jimbe]

点線をさっと書くことが出来たはず…と探してたのですが、 Graphics2D だったんですね。
勝手ながら使わせて頂きました。ありがとうございます。

[TN8001]

どーぞどーぞお気になさらず^^
私のも８割がたググったものですし^^;

[yuki_java]

ご回答本当にありがとうございます。
まだまだ質問の仕方さえ不慣れで申し訳ありません。
手法の検索にあたり、この数の並びから渦巻というキーワードが出てこなかった自分が悲しく思えます。
ですがTN8001さんの記述は思考の手順を示したわかりやすいものでした。

Answer 2

9x9 の盤面のマス目に順番をつける部分だけですが、

class Main {
	public static void main(String[] args) {
		int n = 9;
		int[][] a = getBoard(n);
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++)
				System.out.format("%3d", a[i][j]);
			System.out.println();
		}
	}

	static int[][] getBoard(int n) {
		int[][] a = new int[n][n];
		a[n/2][n/2] = 1;
		for (int v = n * n, i = 0, j = n - 1; n > 1; n -= 2, i++, j--) {
			for (int k = n; --k > 0; ) a[i][j--] = v--;
			for (int k = n; --k > 0; ) a[i++][j] = v--;
			for (int k = n; --k > 0; ) a[i][j++] = v--;
			for (int k = n; --k > 0; ) a[i--][j] = v--;
		}
		return a;
	}
}

Answer 3

取り敢えず描画のみ似せて見ました。
各マスやイベントをクラスにしたり、点線も専用クラスにしています。
各イベントの座標に制限が有るのか無いのかコードから良く分からなかったので、全体を対象にしています。

動かした見た目は殆ど変わらないのに、コードは修正の度に長く…。

package teratail_java.q357803;

import java.awt.*;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class GameFrame extends JFrame {
  public static void main(String[] args) {
    new GameFrame().setVisible(true);
  }

  public GameFrame() {
    super("同好会で作ったやつ");
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setSize(550, 600);
    setLocationRelativeTo(null);

    //ウインドウを大きくしても GamePanel が中央に位置するようにレイアウトを設定
    GridBagLayout layout = new GridBagLayout();
    setLayout(layout);

    GridBagConstraints gbc = new GridBagConstraints();
    gbc.gridx = 0;
    gbc.gridy = 0;
    gbc.gridwidth = 1;
    gbc.gridheight = 1;
    gbc.anchor = GridBagConstraints.CENTER;
    add(new GamePanel(50, 9), gbc); //描画領域の追加
  }

  //マス
  private static class Square {
    enum Direction {
      CENTER, EAST, WEST, NORTH, SOUTH;
    }
    private int number, x, y;
    private int gx, gy, size;
    private Color background = new Color(0, 170, 0);
    private Event event;
    Square(int number, int x, int y, int size) {
      this.number = number;
      this.x = x;
      this.y = y;
      this.size = size;

      this.gx = x * size;
      this.gy = y * size;
    }
    void setEvent(Event event) { this.event = event; }
    //イベントがあるか
    boolean hasEvent() { return event != null; }
    //マスの各方向の座標
    Point getPoint(Direction dir) {
      switch(dir) {
      case EAST:
        return new Point(gx+size, gy+size/2);
      case WEST:
        return new Point(gx, gy+size/2);
      case NORTH:
        return new Point(gx+size/2, gy);
      case SOUTH:
        return new Point(gx+size/2, gy+size);
      default: //CENTER
        return new Point(gx+size/2, gy+size/2);
      }
    }
    void draw(Graphics g) {
      Graphics g2 = g.create();
      g2.setColor(background);
      g2.fillRect(gx, gy, size, size);
      g2.dispose();

      g.drawRect(gx, gy, size, size); //枠

      drawStringAtBottomRight(g, ""+number); //番号
      if(hasEvent()) event.draw(g, gx+2, gy+2); //イベント
    }
    private void drawStringAtBottomRight(Graphics g, String text) {
      FontMetrics fm = g.getFontMetrics();
      int descent = fm.getDescent(); //ベースラインの高さ
      Rectangle2D rect = fm.getStringBounds(text, g);
      int width = (int)rect.getWidth(); //文字列の幅
      g.drawString(text, gx+size-width-1, gy+size-descent-1); //-1 はちょっと隙間
    }
  }

  //イベント
  private static class Event {
    private String text1, text2;
    Event(String text) {
      this.text1 = text;
    }
    Event(String text1, String text2) {
      this.text1 = text1;
      this.text2 = text2;
    }
    void draw(Graphics g, int gx, int gy) {
      FontMetrics fm = g.getFontMetrics();
      gy += fm.getAscent(); //ベースラインから文字頂までの高さ
      g.drawString(text1, gx, gy);
      if(text2 != null) {
        Rectangle2D rect = fm.getStringBounds(text2, g);
        gy += (int)rect.getHeight();
        g.drawString(text2, gx, gy);
      }
    }
  }

  //点線描画
  private static class DotLineDrawer {
    private int x, y;
    private BasicStroke dashed;
    DotLineDrawer(int solid_period) {
      dashed = new BasicStroke(0, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1, new float[]{solid_period}, 0);
    }
    //始点
    void setStart(Point start) {
      x = start.x;
      y = start.y;
    }
    //始点もしくは最後に draw した後から描画
    void draw(Graphics g, Point end) {
      Graphics2D g2 = (Graphics2D)g.create();
      g2.setStroke(dashed);
      g2.drawLine(x, y, end.x, end.y);
      g2.dispose();
      x = end.x;
      y = end.y;
    }
  }

  //右好きの亀さん
  private static class Turtle {
    interface Confirm {
      //安全確認. x,y にマイナスや大きな値が入っても例外を出さないよう注意.
      boolean isSafe(int x, int y);
    }
    enum Direction {
      NORTH(0,-1) { Direction right() { return EAST; } },
      SOUTH(0, 1) { Direction right() { return WEST; } },
      EAST( 1,0) { Direction right() { return SOUTH; } },
      WEST(-1,0) { Direction right() { return NORTH; } };

      final int dx, dy;
      Direction(int dx, int dy) {
        this.dx = dx;
        this.dy = dy;
      }
      abstract Direction right();
    }
    private int x, y;
    private Direction dir;
    private Confirm confirm;
    Turtle(int x, int y, Direction dir, Confirm confirm) {
      this.x = x;
      this.y = y;
      this.dir = dir;
      this.confirm = confirm;
    }
    int getX() { return x; }
    int getY() { return y; }
    void forward() {
      x += dir.dx;
      y += dir.dy;
      Direction sence = dir.right(); //この辺が右好き
      if(confirm.isSafe(x+sence.dx, y+sence.dy)) dir = sence;
    }
  }

  //描画する紙を表すクラス
  private static class GamePanel extends JPanel {
    private List<Square> squareList = new ArrayList<>(); //中心を index=0 とし、螺旋を展開した直線状態
    private Random random = new Random();
    private final int square_size;
    private final int square_count;

    GamePanel(int square_size, int square_count) {
      super(null);
      this.square_size = square_size;
      this.square_count = square_count;

      setPreferredSize(new Dimension(square_size*(square_count+1), square_size*square_count));
      setMinimumSize(getPreferredSize());

      initSquareList();

      squareList.get(0).setEvent(new Event("スタート"));

      setForwardingEvent(); //"進む"イベント(1)
      setRotateEvent("⤵ 90°"); //盤面回転イベント(1)
      setForwardingEvent(); //"進む"イベント(2)
      setRotateEvent("⤵ 180°"); //盤面回転イベント(2)
      setForwardingEvent(); //"進む"イベント(3)
      setToLeftEvent(); //"左へ"イベント
      setForwardingEvent(); //"進む"イベント(4)
      setForwardingEvent(); //"進む"イベント(5)
      setForwardingEvent(); //"進む"イベント(6)
    }

    //マス準備
    private void initSquareList() {
      Turtle turtle = new Turtle(square_count/2, square_count/2, Turtle.Direction.EAST, new Turtle.Confirm() {
        @Override
        public boolean isSafe(int x, int y) {
          for(Square s : squareList) if(s.x == x && s.y == y) return false; //既に通った
          return true;
        }
      });

      for(int number=1; number<=square_count*square_count; turtle.forward(), number++) {
        squareList.add(new Square(number, turtle.getX(), turtle.getY(), square_size));
      }
    }

    //"進む"イベント
    private void setForwardingEvent() {
      Square square = getRandomSquare();
      if(!square.hasEvent()) {
        int a = random.nextInt(5) + 2;
        square.setEvent(new Event("+" + a + "マス"));
      }
    }
    //盤面回転イベント
    private void setRotateEvent(String text2) {
      Square square = getRandomSquare();
      if(!square.hasEvent()) {
        square.setEvent(new Event("盤面", text2));
      }
    }
    //"左へ"イベント
    private void setToLeftEvent() {
      Square square = getRandomSquare();
      if(!square.hasEvent()) {
        square.setEvent(new Event("2マス", "左へ"));
      }
    }

    //ランダムにマスを選択
    private Square getRandomSquare() {
      return getRandomSquare(square_count,0,square_count,0);
    }
    private Square getRandomSquare(int xbound, int xoffset, int ybound, int yoffset) {
      int x = random.nextInt(xbound) + xoffset;
      int y = random.nextInt(ybound) + yoffset;
      return getSquare(x, y);
    }
    //x,y指定から Square を得る
    private Square getSquare(int x, int y) {
      for(Square s : squareList) if(s.x == x && s.y == y) return s;
      return null;
    }

    public void paintComponent(Graphics g) {
      super.paintComponent(g);

      //ゴール
      g.setColor(Color.yellow);
      g.fillRect(square_size*square_count, 0, square_size, square_size);
      g.setColor(Color.black);
      g.drawString("ゴール", square_size*square_count+5, 13);

      //各マス
      for(Square s : squareList) s.draw(g);

      //点線
      DotLineDrawer dotLineDrawer = new DotLineDrawer(5);
      dotLineDrawer.setStart(squareList.get(0).getPoint(Square.Direction.CENTER));
      for(Square s : squareList.subList(1, squareList.size()-1)) {
        dotLineDrawer.draw(g, s.getPoint(Square.Direction.CENTER));
      }
      dotLineDrawer.draw(g, squareList.get(squareList.size()-1).getPoint(Square.Direction.EAST)); //最後はマスの右端まで
    }
  }
}

---

弄ってみたコードを GitHub に入れています。

https://github.com/Jimbe-github/teratail_java/tree/master/workspace2/teratail_java/src/teratail_java/q357803

C.java はオリジナル、C2.java は GameFrame.java から出した Turtle.java を使って C.java の構造を変えずに番号追加(ついでに点線や繰り返し部分を修正)、GameFrame.java は…まぁこちらのより弄っています ^^;;;

Comments

[jimbe]

ベタで書いていた螺旋座標を、タートルグラフィックス風に「右好き」な亀さんの後をなぞって作るようにしました。

[yuki_java]

私の質問にこたえるだけでなく、回転のクラスを作ってくださったり、そもそもの私のかなりわかりにくいコードをクラスごとに分けてくださったりと、かなりのお手数をおかけしていただいたことと、お見受けします。
ご回答ありがとうございました。

[jimbe]

車とかバイクとか自転車とか好きな人が延々と弄っていて飽きないのと同じで、私もコードを延々と弄っているだけですので、手間ということはありません。
それよりも、このようなスゴロクを初めて見たのですが、この後どのようになっていくのかが気になっています。特に、盤面の90度回転とかするとどんな風になっちゃうんでしょう。

[yuki_java]

私もできるだけ早くそれくらいプログラムを好きに操れるようになりたいものです。
今後としてはマス目のイベントに止まった場合＋何マスなどは通常のすごろくと同じですが、90度回転などはその通りにその升目に止まった場合、盤面が駒ごと90度回転することで、ゴール前からいきなり遠いところまで飛ばされたり、逆にゴールから程遠かった人がゴール目の前に来たりといった少し普通のすごろくよりも運の絡むものを作りたいんです。

[jimbe]

私も独学だけでやって来ましたが、今のようにいきなりウインドウを作って線を引くなんてことは出来ない状態からでしたから、否応無く出来ることからするしかなかったので、その分迷うことも少なくてステップアップし易かったのかもしれません。

> ゴール前からいきなり遠いところまで飛ばされたり ～

ということは、番号と点線の表示はそのままで、イベントと駒だけが回転するんですね。
そうすると…私のコードだと、亀さんの向きを変えて得た座標に元の座標の Square を(番号と座標を変えて)移したリストに置き換える感じ…かな? なるほど ゝ。
あ、でも元は紙でイベントを直接盤に書き込んでいたとすると、イベントも回転するのは書き換えが面倒ですね。回転するのは駒だけでしょうか。

[TN8001]

元々の紙のゲームではゴール以外すべてが回るんですよね？

あと１マスでゴールだって時に誰かが回転イベントに乗ってしまい盤面（当然イベントも含むし乗っている駒も同様）が回ることで、ゴール目前だった人がまた３／４周程度しなくてはならなくなる。と

紙のゲームならそれでいいと思うんですよ。
しかしＰＣのゲーム（コンピュータゲーム）となると、まったく同じデザインというわけにもいかないと思うんですよね。

（罫線引くのが面倒なので）３＊３で考えてみます。
┏━┳━┳━┓
┃┌╂─╂─╂Ｇ
┣┿╋━╋━┫
┃│┃Ｓ╂┐┃
┣┿╋━╋┿┫
┃└╂─╂┘┃
┗━┻━┻━┛
誰かが９０度回してしまいました。
┏━┳━┳━┓
┃┌╂─╂┐┃Ｇ
┣┿╋━╋┿┫
┃│┃Ｓ┃│┃
┣┿╋┿╋┿┫
┃└╂┘││┃
┗━┻━┻┿┛
こうなります。
紙のゲームでは右上のマスの次はゴール・右下のマスの次は左に行くとみんなが了解しているでしょう（いちいち線を書き換えるわけにはいかないし^^;

しかしＰＣゲームなら自由に書き換えられます（実際にそれを実装する手間は考慮しない）
もし書き換えるならこうなるでしょう。
┏━┳━┳━┓
┃┌╂─╂─╂Ｇ
┣┿╋━╋━┫
┃│┃Ｓ┃│┃
┣┿╋┿╋┿┫
┃└╂┴╂┘┃
┗━┻━┻━┛
元々左上だったマスが右上になりゴールに接したことでゴール直前マスになり、右下では合流地点もできてしまいました。

盤の回転がなければ１直線で考えられたのですが、そうもいかなくなってしまいました（それをどう実現するかを考えるのもそれはそれで面白いと思いますが）

上記問題が見え見えだったため、私の回答では盤は動かず駒だけを点対称な位置に回転させました（イベントも動かせますが、個人的には盤が回らない以上動かないほうが自然な気はします。ゴール直前のイベントラッシュも作りやすいですし）

アナログゲームでパッと点対称な位置を探すのは面倒かもしれませんが、ＰＣが勝手にやってくれるなら問題ないわけです。

盤は動かないため１直線性が保証され実装しやすくなるのです（駒だけ飛んだとしてもゲーム性は変わっていないでしょう）

ということを回答コードに込めたつもりなのですが、もし実行しても伝わらなかったとすれば言葉足らずでした^^;

[jimbe]

これはなかなか、同好会で作られたそうですが、その時もきっと試行錯誤されたんでしょうね ^^