トップページ > 記事閲覧
迷路について2
名前：FFGX 日時： 2020/06/08 10:54 

今僕は疑似3dダンジョンを作っています。
ですが画像を重ねてbufという変数に保存したいと思っています。
<loading.h>
#pragma once
#include<DxLib.h>
int gr[15][4];
int gr2[4];
void loading() {
	gr[0][2] = LoadGraph("madia\\0_2.png", true);
	gr[1][2] = LoadGraph("madia\\1_2.png", true);
	gr[2][2] = LoadGraph("madia\\2_2.png", true);
	gr[3][2] = LoadGraph("madia\\3_2.png", true);
	gr[3][3] = LoadGraph("madia\\3_3.png", true);
	gr[4][1] = LoadGraph("madia\\4_2.png", true);
	gr[4][2] = LoadGraph("madia\\4_3.png", true);
	gr[5][2] = LoadGraph("madia\\5_2.png", true);
	gr[6][2] = LoadGraph("madia\\6_2.png", true);
	gr[6][3] = LoadGraph("madia\\6_3.png", true);
	gr[7][1] = LoadGraph("madia\\7_2.png", true);
	gr[7][2] = LoadGraph("madia\\7_3.png", true);
	gr[8][2] = LoadGraph("madia\\8_2.png", true);
	gr[9][2] = LoadGraph("madia\\9_2.png", true);
	gr[9][3] = LoadGraph("madia\\9_3.png", true);
	gr[10][1] = LoadGraph("madia\\10_1.png", true);
	gr[10][2] = LoadGraph("madia\\10_2.png", true);
	gr[11][2] = LoadGraph("madia\\11_2.png", true);
	gr[12][3] = LoadGraph("madia\\12_3.png", true);
	gr[13][1] = LoadGraph("madia\\13_1.png", true);
	gr2[0] = LoadGraph("madia\\_0.png", true);
	gr2[1] = LoadGraph("madia\\_1.png", true);
	gr2[2] = LoadGraph("madia\\_2.png", true);
	gr2[3] = LoadGraph("madia\\_3.png", true);
}
<define.h>
#pragma once
#include"loading.h"
#define ROAD 0
#define WALL 1

#define LOCATION_MAX 15
#define ONE 42

int maphierarchy = 1;

enum {
	DIRECTION_N,
	DIRECTION_W,
	DIRECTION_S,
	DIRECTION_E,
	DIRECTION_MAX
};

enum {
	WALL_NONE,
	WALL_WALL,
	WALL_MAX
};

int location[DIRECTION_MAX][LOCATION_MAX][2] = {
	{
		{-1,-4}, {1,-4}, {0,-4},
		{-1,-3}, {1,-3}, {0,-3},
		{-1,-2}, {1,-2}, {0,-2},
		{-1,-1}, {1,-1}, {0,-1},
		{-1,0}, {1,0}, {0,0},
	}, {
		{-4,1}, {-4,-1}, {-4,0},
		{-3,1}, {-3,-1}, {-3,0},
		{-2,1}, {-2,-1}, {-2,0},
		{-1,1}, {-1,-1}, {-1,0},
		{0,1}, {0,-1}, {0,0},
	}, {
		{-1,-4}, {1,-4}, {0,-4},
		{-1,-3}, {1,-3}, {0,-3},
		{-1,-2}, {1,-2}, {0,-2},
		{-1,-1}, {1,-1}, {0,-1},
		{-1,0}, {1,0}, {0,0},
	}, {
		{-4,1}, {-4,-1}, {-4,0},
		{-3,1}, {-3,-1}, {-3,0},
		{-2,1}, {-2,-1}, {-2,0},
		{-1,1}, {-1,-1}, {-1,0},
		{0,1}, {0,-1}, {0,0},
	},
};

int walls[ONE][ONE][DIRECTION_MAX] = {
	省略
};

int Px, Py = 41,Pd;

int aa[LOCATION_MAX][DIRECTION_MAX] = {
	{NULL,NULL,gr[0][2],NULL},{NULL,NULL,gr[1][2],NULL},{NULL,NULL,gr[2][2],NULL},
	{gr[0][2],NULL,gr[3][2],gr[3][3]},{gr[1][2],gr[4][1],gr[0][2],NULL},{gr[2][2],gr[3][3],gr[5][2],gr[4][1]},
	{gr[3][2],NULL,gr[6][2],gr[6][3]},{gr[4][2],gr[7][1],gr[7][2],NULL},{gr[5][2],gr[6][3],gr[8][2],gr[7][1]},
	{gr[6][2],NULL,gr[9][2],gr[9][3]},{gr[7][2],gr[10][1],gr[10][2],NULL},{gr[8][2],gr[9][3],gr[11][2],gr[10][1]},
	{gr[9][2],NULL,NULL,gr[12][3]},{gr[10][2],gr[13][1],NULL,NULL},{gr[11][2],gr[12][3],NULL,gr[13][1]},
};
<main.cpp>
#include "define.h"

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) {
	SetOutApplicationLogValidFlag(false);
	SetWindowText("maze");
	ChangeWindowMode(true);
	SetBackgroundColor(255, 255, 255);
	SetDrawScreen(DX_SCREEN_BACK);
	DxLib_Init();
	int buf;
	loading();// 読み込み
	while (1) {
		ClearDrawScreen();
		for (int i = 0; i < LOCATION_MAX; i++) {
			int x = Px + location[Pd][i][0],
				y = Py + location[Pd][i][1];
			x = (ONE + x) % ONE;
			y = (ONE + y) % ONE;
			for (int j = 0; j < DIRECTION_MAX; j++) {
				int dir = (Pd + j) % DIRECTION_MAX;
				if (walls[y][x][dir] == WALL_WALL) {
					int src = aa[i][j];
					if (src != NULL) {
						buf = DerivationGraph(0, 0, 640, 480, src);
					}
				}
			}
		}
		DrawGraph(0, 0, buf, true);
		ScreenFlip();
		if (ProcessMessage() != 0)
			break;
		if (CheckHitKey(KEY_INPUT_ESCAPE))
			break;
	}
	DxLib_End();
	return 0;
}
これだと
1.ローディング
2.画面消去
3.壁を裏画面に描画
4.裏画面を表画面に
の3.ができません
助けてください。
メンテ

Page: 1 | 2 |

Re: 迷路について2 ( No.20 )
名前：FFGX 日時：2020/06/30 07:19 

補足
12_3,11_2,10_1,10_2
が初期状態で
右か左かを押すと
10_1,11_2,12_3,13_1
が表示されました。
メンテ
Re: 迷路について2 ( No.21 )
名前：管理人 日時：2020/06/30 22:19 

以前より更に謎なプログラムになっているように感じます

本件の３Ｄダンジョンのマップを描画するプログラムは全てFFGXさんが考えられたものなのでしょうか？
メンテ
Re: 迷路について2 ( No.22 )
名前：FFGX 日時：2020/07/01 16:01 

for(int j; j < DIRECTION_MAX; j++)
はいりませんでした。
ちなみに
fovは-1で初期化しています。
＜本件の３Ｄダンジョンのマップを描画するプログラムは全てFFGXさんが考えられたものなのでしょうか？
はいそうです。
1.壁のデータをdataに保存
2.もしdata[i]が0(壁)だったら
2.1ロケーションが右斜め下だったらflagを立てる
2.2ロケーションが左斜め上だったらflagを立てる
2.3ロケーションが中央だったらflagを立てる
2.4ロケーションが右だったらflagを立てる
2.5ロケーションが左だったらflagを立てる
2.6ロケーションが上だったらflagを立てる
3.仕分け
4.描画
という流れにしたいです。
メンテ
Re: 迷路について2 ( No.23 )
名前：管理人 日時：2020/07/02 00:37 

>　for(int j; j < DIRECTION_MAX; j++)
>　はいりませんでした。
>　ちなみに
>　fovは-1で初期化しています。

すみません、細かい部分が変更されているようなので、最新のプログラムを
再度こちらの掲示板に全部貼り付けていただけないでしょうか？

>　＜本件の３Ｄダンジョンのマップを描画するプログラムは全てFFGXさんが考えられたものなのでしょうか？
>　はいそうです。

そうですか…
FFGXさんが考えられた処理を FFGXさん自身が理解できていないとなりますと、
そもそもこの処理では３Ｄダンジョンのマップを正常に描画できないかもしれません

>　1.壁のデータをdataに保存
>　2.もしdata[i]が0(壁)だったら
>　2.1ロケーションが右斜め下だったらflagを立てる
>　2.2ロケーションが左斜め上だったらflagを立てる
>　2.3ロケーションが中央だったらflagを立てる
>　2.4ロケーションが右だったらflagを立てる
>　2.5ロケーションが左だったらflagを立てる
>　2.6ロケーションが上だったらflagを立てる
>　3.仕分け
>　4.描画

LOCATION_MAX は #define で 14 と定義されていますが、0 から 13 までの値は
それぞれ何を意味しているのでしょうか？
メンテ
Re: 迷路について2 ( No.24 )
名前：FFGX 日時：2020/07/02 16:19 

<loading.h>
#pragma once
#include<DxLib.h>

#define LOCATION_MAX 15

int gr[LOCATION_MAX][4];
int aa[LOCATION_MAX][4];
void loading() {
	gr[0][2] = LoadGraph("madia\\0_2.png", true);
	gr[1][2] = LoadGraph("madia\\1_2.png", true);
	gr[2][2] = LoadGraph("madia\\2_2.png", true);
	gr[3][2] = LoadGraph("madia\\3_2.png", true);
	gr[3][3] = LoadGraph("madia\\3_3.png", true);
	gr[4][1] = LoadGraph("madia\\4_1.png", true);
	gr[4][2] = LoadGraph("madia\\4_2.png", true);
	gr[5][2] = LoadGraph("madia\\5_2.png", true);
	gr[6][2] = LoadGraph("madia\\6_2.png", true);
	gr[6][3] = LoadGraph("madia\\6_3.png", true);
	gr[7][1] = LoadGraph("madia\\7_1.png", true);
	gr[7][2] = LoadGraph("madia\\7_2.png", true);
	gr[8][2] = LoadGraph("madia\\8_2.png", true);
	gr[9][2] = LoadGraph("madia\\9_2.png", true);
	gr[9][3] = LoadGraph("madia\\9_3.png", true);
	gr[10][1] = LoadGraph("madia\\10_1.png", true);
	gr[10][2] = LoadGraph("madia\\10_2.png", true);
	gr[11][2] = LoadGraph("madia\\11_2.png", true);
	gr[12][3] = LoadGraph("madia\\12_3.png", true);
	gr[13][1] = LoadGraph("madia\\13_1.png", true);
	aa[0][0] = NULL;
	aa[0][1] = NULL;
	aa[0][2] = gr[0][2];
	aa[0][3] = NULL;

	aa[1][0] = NULL;
	aa[1][1] = NULL;
	aa[1][2] = gr[1][2];
	aa[1][3] = NULL;

	aa[2][0] = NULL;
	aa[2][1] = NULL;
	aa[2][2] = gr[2][2];
	aa[2][3] = NULL;

	aa[3][0] = gr[0][2];
	aa[3][1] = NULL;
	aa[3][2] = gr[3][2];
	aa[3][3] = gr[3][3];

	aa[4][0] = gr[1][2];
	aa[4][1] = gr[4][1];
	aa[4][2] = gr[4][2];
	aa[4][3] = NULL;

	aa[5][0] = gr[2][2];
	aa[5][1] = gr[3][3];
	aa[5][2] = gr[5][2];
	aa[5][3] = gr[4][1];

	aa[6][0] = gr[3][2];
	aa[6][1] = NULL;
	aa[6][2] = gr[6][2];
	aa[6][3] = gr[6][3];

	aa[7][0] = gr[4][2];
	aa[7][1] = gr[7][1];
	aa[7][2] = gr[7][2];
	aa[7][3] = NULL;

	aa[8][0] = gr[5][2];
	aa[8][1] = gr[6][3];
	aa[8][2] = gr[8][2];
	aa[8][3] = gr[7][1];

	aa[9][0] = gr[6][2];
	aa[9][1] = NULL;
	aa[9][2] = gr[9][2];
	aa[9][3] = gr[9][3];

	aa[10][0] = gr[7][2];
	aa[10][1] = gr[10][1];
	aa[10][2] = gr[10][2];
	aa[10][3] = NULL;

	aa[11][0] = gr[8][2];
	aa[11][1] = gr[9][3];
	aa[11][2] = gr[11][2];
	aa[11][3] = gr[10][1];

	aa[12][0] = gr[9][2];
	aa[12][1] = NULL;
	aa[12][2] = NULL;
	aa[12][3] = gr[12][3];

	aa[13][0] = gr[10][2];
	aa[13][1] = gr[13][1];
	aa[13][2] = NULL;
	aa[13][3] = NULL;

	aa[14][0] = gr[11][2];
	aa[14][1] = gr[12][3];
	aa[14][3] = gr[13][1];
}
<define.h>
#pragma once
#include"loading.h"

#define ONE 41

int maphierarchy = 1;

enum {
	DIRECTION_N,
	DIRECTION_W,
	DIRECTION_S,
	DIRECTION_E,
	DIRECTION_MAX
};

enum {
	WALL_NONE,
	WALL_WALL,
	WALL_MAX
};

int location[DIRECTION_MAX][LOCATION_MAX][2] = {
	{ // 0
		{-1,-4}, {1,-4}, {0,-4},
		{-1,-3}, {1,-3}, {0,-3},
		{-1,-2}, {1,-2}, {0,-2},
		{-1,-1}, {1,-1}, {0,-1},
		{-1,0}, {1,0}, {0,0}
	}, { // 1
		{-4,1}, {-4,-1}, {-4,0},
		{-3,1}, {-3,-1}, {-3,0},
		{-2,1}, {-2,-1}, {-2,0},
		{-1,1}, {-1,-1}, {-1,0},
		{0,1}, {0,-1}, {0,0}
	}, { // 2
		{-1,4}, {1,4}, {0,4},
		{-1,3}, {1,3}, {0,3},
		{-1,2}, {1,2}, {0,2},
		{-1,1}, {1,1}, {0,1},
		{-1,0}, {1,0}, {0,0}
	}, { // 3
		{4,-1}, {4,1}, {4,0},
		{3,-1}, {3,1}, {3,0},
		{2,-1}, {2,1}, {2,0},
		{1,-1}, {1,1}, {1,0},
		{0,-1}, {0,1}, {0,0}
	},
};

int maps[ONE][ONE] = {
	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
	{0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0},
	{0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0},
	{0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0},
	{0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0},
	{0,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,0},
	{0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0},
	{0,1,0,1,1,1,0,1,1,1,0,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,0,1,0},
	{0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0},
	{0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0},
	{0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0},
	{0,1,0,1,0,1,1,1,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0},
	{0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0},
	{0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
	{0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0},
	{0,1,0,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,0},
	{0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0},
	{0,1,1,1,1,1,0,1,1,1,0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0},
	{0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0},
	{0,1,0,1,0,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,0},
	{0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0},
	{0,1,1,1,0,1,0,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,0},
	{0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0},
	{0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0},
	{0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0},
	{0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0},
	{0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0},
	{0,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,0},
	{0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0},
	{0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0},
	{0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0},
	{0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0},
	{0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0},
	{0,1,1,1,0,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,0},
	{0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0},
	{0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,0,1,0},
	{0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0},
	{0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,0},
	{0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0},
	{0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,0},
	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
};

int Px = 1, Py = 1,Pd = 2;

int fov[LOCATION_MAX][DIRECTION_MAX] = {
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1},
	{-1,-1,-1,-1}
}; //壁のデータ保存用(3次元)
int fov2[LOCATION_MAX][DIRECTION_MAX]; //グラフィックデータ保存用
<main.cpp>
#include "define.h"

void check_and_paint() {
	int data[LOCATION_MAX];
	for (int i = 0; i < LOCATION_MAX; i++) {
		data[i] = maps[Px + location[Pd][i][0]][Py + location[Pd][i][1]];
	}
	for (int i = 0; i < LOCATION_MAX; i++) {
		for (int j = 0; j < DIRECTION_MAX; j++) {
			if (data[i] == 0) {
				switch (i) {
				case 13:
					fov[i][0] = 0;
					fov[i][1] = 1;
					break;
				case 12:
					fov[i][0] = 0;
					fov[i][3] = 3;
					break;
				case 5:
				case 8:
				case 11:
					fov[i][0] = 0;
					fov[i][1] = 1;
					fov[i][2] = 2;
					fov[i][3] = 3;
					break;
				case 4:
				case 7:
				case 10:
					fov[i][0] = 0;
					fov[i][1] = 1;
					fov[i][2] = 2;
					break;
				case 3:
				case 6:
				case 9:
					fov[i][0] = 0;
					fov[i][2] = 2;
					fov[i][3] = 3;
					break;
				case 0:
				case 1:
				case 2:
					fov[i][2] = 2;
					break;
				}
			}
		}
	}
	for (int i = 0; i < LOCATION_MAX; i++) {
		for (int j = 0; j < DIRECTION_MAX; j++) {
			if (fov[i][j] == -1) {
				continue;
			}
			else {
				fov2[i][j] = aa[i][fov[i][j]];
			}
		}
	}
	for (int i = 0; i < LOCATION_MAX; i++) {
		for (int j = 0; j < DIRECTION_MAX; j++) {
			if (fov2[i][j]) {
				DrawGraph(0, 0, fov2[i][j], true);
			}
		}
	}
}

void mapPaint() {
	check_and_paint();
	DrawBox(480, 0, 640, 480,GetColor(0, 0, 0), true);
}

void mainloop() {
	ClearDrawScreen();
	mapPaint();
	ScreenFlip();
	if (CheckHitKey(KEY_INPUT_UP)) {
		if (Pd==0) {

		}
		WaitTimer(200);
	}
	if (CheckHitKey(KEY_INPUT_DOWN)) {
		Pd += 2;
		if (Pd == 4)
			Pd = 0;
		if (Pd == 5)
			Pd = 1;
		WaitTimer(200);
	}
	if (CheckHitKey(KEY_INPUT_RIGHT)) {
		Pd--;
		if (Pd == -1)
			Pd = 3;
		WaitTimer(200);
	}
	if (CheckHitKey(KEY_INPUT_LEFT)) {
		Pd++;
		if (Pd == 4)
			Pd = 0;
		WaitTimer(200);
	}
}

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) {
	SetOutApplicationLogValidFlag(false);
	SetWindowText("maze");
	ChangeWindowMode(true);
	SetBackgroundColor(255, 255, 255);
	DxLib_Init();
	SetDrawScreen(DX_SCREEN_BACK);
	loading();// 読み込み
	while (1) {
		mainloop();
		if (ProcessMessage() != 0)
			break;
		if (CheckHitKey(KEY_INPUT_ESCAPE))
			break;
	}
	DxLib_End();
	return 0;
}
です。
メンテ
Re: 迷路について2 ( No.25 )
名前：管理人 日時：2020/07/02 23:53 

最新のプログラムの貼り付けありがとうございます

こちらのご質問にもお答えいただけないでしょうか？

>　1.壁のデータをdataに保存
>　2.もしdata[i]が0(壁)だったら
>　2.1ロケーションが右斜め下だったらflagを立てる
>　2.2ロケーションが左斜め上だったらflagを立てる
>　2.3ロケーションが中央だったらflagを立てる
>　2.4ロケーションが右だったらflagを立てる
>　2.5ロケーションが左だったらflagを立てる
>　2.6ロケーションが上だったらflagを立てる
>　3.仕分け
>　4.描画

LOCATION_MAX は #define で 14 と定義されていますが、0 〜 13 の値は
それぞれ何を意味しているのでしょうか？
メンテ
Re: 迷路について2 ( No.26 )
名前：FFGX 日時：2020/07/03 15:54 

あ、すみませんでした。
＞LOCATION_MAX は #define で 14 と定義されていますが、0 〜 13
LOCATION_MAXは15です。
0 2 1
3 5 4
6 8 7
9 10 11
12 14 13
画像の並べ方です。
メンテ
Re: 迷路について2 ( No.27 )
名前：管理人 日時：2020/07/04 00:07 

ご説明ありがとうございます

>　LOCATION_MAXは15です。
>　0 2 1
>　3 5 4
>　6 8 7
>　9 10 11
>　12 14 13
>　画像の並べ方です。

画像の並べ方ですか…
『画像』というのは以前頂いた 9_3.png や 13_1.png などの画像だと思うのですが、
画像については以前頂いた時から変化はありますでしょうか？
( もし変化していたら、現在の最新版を頂けないでしょうか？ )
メンテ
Re: 迷路について2 ( No.28 )
名前：Tatu 日時：2020/07/04 01:00 

locationはプレイヤーから見てどういう位置かではないでしょうか。
0:前4左
1:前4右
2:前4
3:前3左
4:前3右
5:前3
6:前2左
7:前2右
8:前2
9:前1左
10:前1右
11:前1
12:左
13:右
14:現在地
メンテ
Re: 迷路について2 ( No.29 )
名前：FFGX 日時：2020/07/04 08:15 

そうでした。
そのことについて説明するのを忘れてました。
＞画像については以前頂いた時から変化はありますでしょうか？
変化はありません。
メンテ
Re: 迷路について2 ( No.30 )
名前：管理人 日時：2020/07/04 22:40 

>　Tatuさん

ご説明いただきありがとうございます m(_ _)m


>　FFGXさん

>　＞画像については以前頂いた時から変化はありますでしょうか？
>　変化はありません。

了解です

Tatuさんのご説明と併せて考えますと…
media の画像が正しくないように感じます

0_2.png と 1_2.png は４つ先の１マス左の壁と１マス右の壁の画像だと思うのですが、
2_2.png は正方形なのに、何故 0_2.png と 1_2.png は縦長の長方形なのでしょうか？
メンテ
Re: 迷路について2 ( No.31 )
名前：FFGX 日時：2020/07/05 18:34 

それについては、
＼
　＼
　｜
　｜＿＿＿＿＿＿＿
　｜　｜
　｜　｜
　｜　｜
　｜　｜
　｜　｜
　｜　｜
　｜＿＿＿＿＿＿＿
　｜
　｜
　／
／
このような場合があるためです。
メンテ
Re: 迷路について2 ( No.32 )
名前：管理人 日時：2020/07/05 22:33 

なるほど、了解です

では、そのような場合ではない( 奥の壁が手前の壁で隠されない )ときは、どのように描画するのでしょうか？

やはり正方形の壁の画像が必要だと思うのですが…
メンテ
Re: 迷路について2 ( No.33 )
名前：FFGX 日時：2020/07/06 16:28 

そのような場合はありません。
画像を重ねて、その画像を送ります。
メンテ
Re: 迷路について2 ( No.34 )
名前：管理人 日時：2020/07/07 00:38 

ご返答ありがとうございます

何となく把握できました

すみません、最後に確認させてください

迷路の通路は絶対１マスの幅しかないという前提でしょうか？

例えば■を壁、□を通路としまして

■■■■■■■■■■■■
■□□□□□□□□□□■
■□□■■■■■□□□■
■□□■■■■■□□□■
■□□■■■■■□■■■
■□□■■■■■□■■■

↑このような２マス分の幅がある通路や、縦横３マス分の広さがある空間などは無い
と考えて良いのでしょうか？
メンテ
Re: 迷路について2 ( No.35 )
名前：FFGX 日時：2020/07/07 07:19 

ないです。
迷路の道は1マス分です。
メンテ
Re: 迷路について2 ( No.36 )
名前：管理人 日時：2020/07/08 01:28 

>　ないです。
>　迷路の道は1マス分です。

ご返答ありがとうございます、了解です

背景を描画している関数 check_and_paint ですが

void check_and_paint() {
	int data[LOCATION_MAX];
	for (int i = 0; i < LOCATION_MAX; i++) {
		data[i] = maps[Px + location[Pd][i][0]][Py + location[Pd][i][1]];
	}
	for (int i = 0; i < LOCATION_MAX; i++) {
		for (int j = 0; j < DIRECTION_MAX; j++) {
			if (data[i] == 0) {
				switch (i) {
				case 13:
					fov[i][0] = 0;
					fov[i][1] = 1;
					break;
				case 12:
					fov[i][0] = 0;
					fov[i][3] = 3;
					break;
				case 5:
				case 8:
				case 11:
					fov[i][0] = 0;
					fov[i][1] = 1;
					fov[i][2] = 2;
					fov[i][3] = 3;
					break;
				case 4:
				case 7:
				case 10:
					fov[i][0] = 0;
					fov[i][1] = 1;
					fov[i][2] = 2;
					break;
				case 3:
				case 6:
				case 9:
					fov[i][0] = 0;
					fov[i][2] = 2;
					fov[i][3] = 3;
					break;
				case 0:
				case 1:
				case 2:
					fov[i][2] = 2;
					break;
				}
			}
		}
	}
	for (int i = 0; i < LOCATION_MAX; i++) {
		for (int j = 0; j < DIRECTION_MAX; j++) {
			if (fov[i][j] == -1) {
				continue;
			}
			else {
				fov2[i][j] = aa[i][fov[i][j]];
			}
		}
	}
	for (int i = 0; i < LOCATION_MAX; i++) {
		for (int j = 0; j < DIRECTION_MAX; j++) {
			if (fov2[i][j]) {
				DrawGraph(0, 0, fov2[i][j], true);
			}
		}
	}
}

FFGXさんは、プレイヤーの位置と向きから見た

0:前4左
1:前4右
2:前4
3:前3左
4:前3右
5:前3
6:前2左
7:前2右
8:前2
9:前1左
10:前1右
11:前1
12:左
13:右
14:現在地

の位置が壁かどうかで描画する画像を選択されようとしていますが、
発想を逆転して

『各画像が、どの条件のときに描画されるのか』

という処理に変更した方が良いと思います

というのも、例えば『3_3.png』は『前２マス左１マス』の位置にある壁の側面の画像ですが、
『前２マス』の位置にも壁があったら描画する必要はない( 正面に壁があるので側面は見えない )です
更に『前１マス』の位置に位置に壁がある場合も隠れてしまうので描画する必要はなくなります

というように、『前〇マス左右〇マスに壁があったら画像を描画』というような単純な条件では
画像を描画するべきかどうかを判定できないので、

『壁』基準で描画する画像を決めるのではなく

『画像』基準で描画するかどうかを決めた方が良いです

なので例えば『3_3.png』を描画する処理としては

	if( data[6] == 0 &&	// 前2左1が壁で
	    data[8] == 1 &&	// 前2は壁ではなく
	    data[11] == 1 )	// 前1も壁ではない場合
	{
		DrawGraph( 0, 0, gr[3][3], TRUE );	// 3_3.png を描画する
	}

↑このようになります

もう一つ例として『前４マス左１マス』の位置にある壁を正面から見た画像の『0_2.png』を描画する処理としては

	if( data[0] == 0 &&	// 前4左1が壁で
	    data[3] == 1 &&	// 前3左1は壁ではなく
	    data[5] == 1 &&	// 前3も壁ではなく
	    data[8] == 1 &&	// 前2も壁ではなく
	    data[11] == 1 )	// 前1も壁ではない場合
	{
		DrawGraph( 0, 0, gr[0][2], TRUE );	// 0_2.png を描画する
	}

↑このようになります

このような処理を 0_2.png 1_2.png 2_2.png 3_2.png 3_3.png 4_1.png 4_2.png
5_2.png 6_2.png 6_3.png 7_1.png 7_2.png 8_2.png 9_2.png 9_3.png
10_1.png 10_2.png 11_2.png 12_3.png 13_1.png の全てについて書けば関数 check_and_paint は完成です

void check_and_paint() {
	int data[LOCATION_MAX];
	for (int i = 0; i < LOCATION_MAX; i++) {
		data[i] = maps[Px + location[Pd][i][0]][Py + location[Pd][i][1]];
	}
	// 0_2.pngを描画する処理
	if( data[0] == 0 &&	// 前4左1が壁で
	    data[3] == 1 &&	// 前3左1は壁ではなく
	    data[5] == 1 &&	// 前3も壁ではなく
	    data[8] == 1 &&	// 前2も壁ではなく
	    data[11] == 1 )	// 前1も壁ではない場合
	{
		DrawGraph( 0, 0, gr[0][2], TRUE );	// 0_2.png を描画する
	}

	// 1_2.pngを描画する処理

	// 2_2.pngを描画する処理

	// 3_2.pngを描画する処理

	// 3_3.pngを描画する処理
	if( data[6] == 0 &&	// 前2左1が壁で
	    data[8] == 1 &&	// 前2は壁ではなく
	    data[11] == 1 )	// 前1も壁ではない場合
	{
		DrawGraph( 0, 0, gr[3][3], TRUE );	// 3_3.png を描画する
	}

	// 4_1.pngを描画する処理

	// 4_2.pngを描画する処理

	// 5_2.pngを描画する処理

	// 6_2.pngを描画する処理

	// 6_3.pngを描画する処理

	// 7_1.pngを描画する処理

	// 7_2.pngを描画する処理

	// 8_2.pngを描画する処理

	// 9_2.pngを描画する処理

	// 9_3.pngを描画する処理

	// 10_1.pngを描画する処理

	// 10_2.pngを描画する処理

	// 11_2.pngを描画する処理

	// 12_3.pngを描画する処理

	// 13_1.pngを描画する処理
}

↑( 20個の画像全部の処理を書くのは大変なので、残りは FFGXさんが書いてください… )

因みに『前４マス左１マス』を『0』と書いたり『前２マス』を『8』と書いたりするのは
直感的ではないと思うので、LOCATION も enum にして

enum {
	LOCATION_F4_L,	// 0:前4左
	LOCATION_F4_R,	// 1:前4右
	LOCATION_F4,	// 2:前4
	LOCATION_F3_L,	// 3:前3左
	LOCATION_F3_R,	// 4:前3右
	LOCATION_F3,	// 5:前3
	LOCATION_F2_L,	// 6:前2左
	LOCATION_F2_R,	// 7:前2右
	LOCATION_F2,	// 8:前2
	LOCATION_F1_L,	// 9:前1左
	LOCATION_F1_R,	// 10:前1右
	LOCATION_F1,	// 11:前1
	LOCATION_L,	// 12:左
	LOCATION_R,	// 13:右
	LOCATION_C,	// 14:現在地
	LOCATION_MAX	// 15
};

↑このように定義した方が良いと思います、そうすれば先程の if文も

	if( data[LOCATION_F4_L] == 0 &&	// 前4左1が壁で
	    data[LOCATION_F3_L] == 1 &&	// 前3左1は壁ではなく
	    data[LOCATION_F3] == 1 &&	// 前3も壁ではなく
	    data[LOCATION_F2] == 1 &&	// 前2も壁ではなく
	    data[LOCATION_F1] == 1 )	// 前1も壁ではない場合
	{
		DrawGraph( 0, 0, gr[0][2], TRUE );	// 0_2.png を描画する
	}

↑このようになり、コメントが無くても意味が分かる感じになります
メンテ
Re: 迷路について2 ( No.37 )
名前：FFGX 日時：2020/07/10 17:07 

aaとfovとfov2は削除しました。
LOCATION も enum にしてみました。
つまりは、
if (data[LOCATION_F4_L] == 0 &&
		data[LOCATION_F3_L] == 1 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[0][2], true);
	}
	if (data[LOCATION_F4_R] == 0 &&
		data[LOCATION_F3_R] == 1 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[1][2], true);
	}
	if (data[LOCATION_F4] == 0 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[2][2], true);
	}
	if (data[LOCATION_F3_L] == 0 &&
		data[LOCATION_F2_L] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[3][2], true);
	}
	if (data[LOCATION_F2_L] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[3][3], true);
	}
	if (data[LOCATION_F2_R] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[4][1], true);
	}
	if (data[LOCATION_F3_R] == 0 &&
		data[LOCATION_F2_R] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[4][2], true);
	}
	if (data[LOCATION_F3] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[5][2], true);
	}
	if (data[LOCATION_F2_L] == 0 &&
		data[LOCATION_F1_L] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[6][2], true);
	}
	if (data[LOCATION_F2_L] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[6][3], true);
	}
	if (data[LOCATION_F2_R] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[7][1], true);
	}
	if (data[LOCATION_F2_L] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[7][2], true);
	}
	if (data[LOCATION_F2] == 0 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[8][2], true);
	}
	if (data[LOCATION_F1_L] == 0 &&
		data[LOCATION_L] == 1)
	{
		DrawGraph(0, 0, gr[9][2], true);
	}
	if (data[LOCATION_F1_L] == 0 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[9][3], true);
	}
	if (data[LOCATION_F1_R] == 0 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[10][1], true);
	}
	if (data[LOCATION_F1_R] == 0 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[10][2], true);
	}
	if (data[LOCATION_F1] == 0)
	{
		DrawGraph(0, 0, gr[11][2], true);
	}
	if (data[LOCATION_L] == 0)
	{
		DrawGraph(0, 0, gr[12][2], true);
	}
	if (data[LOCATION_R] == 0)
	{
		DrawGraph(0, 0, gr[13][2], true);
	}
こういうことでしょうか。
メンテ
Re: 迷路について2 ( No.38 )
名前：管理人 日時：2020/07/11 07:22 

はい、そんな感じです、殆ど正解です

ただ、壁の側面の判定幾つかと 10_2.png の判定が少し違いました、手元で正常に描画されるようにしたところ

	if (data[LOCATION_F4_L] == 0 &&
		data[LOCATION_F3_L] == 1 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[0][2], true);
	}
	if (data[LOCATION_F4_R] == 0 &&
		data[LOCATION_F3_R] == 1 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[1][2], true);
	}
	if (data[LOCATION_F4] == 0 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[2][2], true);
	}
	if (data[LOCATION_F3_L] == 0 &&
		data[LOCATION_F2_L] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[3][2], true);
	}
	if (data[LOCATION_F3_L] == 0 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[3][3], true);
	}
	if (data[LOCATION_F3_R] == 0 &&
		data[LOCATION_F3] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[4][1], true);
	}
	if (data[LOCATION_F3_R] == 0 &&
		data[LOCATION_F2_R] == 1 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[4][2], true);
	}
	if (data[LOCATION_F3] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[5][2], true);
	}
	if (data[LOCATION_F2_L] == 0 &&
		data[LOCATION_F1_L] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[6][2], true);
	}
	if (data[LOCATION_F2_L] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[6][3], true);
	}
	if (data[LOCATION_F2_R] == 0 &&
		data[LOCATION_F2] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[7][1], true);
	}
	if (data[LOCATION_F2_L] == 0 &&
		data[LOCATION_F1] == 1 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[7][2], true);
	}
	if (data[LOCATION_F2] == 0 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[8][2], true);
	}
	if (data[LOCATION_F1_L] == 0 &&
		data[LOCATION_L] == 1)
	{
		DrawGraph(0, 0, gr[9][2], true);
	}
	if (data[LOCATION_F1_L] == 0 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[9][3], true);
	}
	if (data[LOCATION_F1_R] == 0 &&
		data[LOCATION_F1] == 1)
	{
		DrawGraph(0, 0, gr[10][1], true);
	}
	if (data[LOCATION_F1_R] == 0 &&
		data[LOCATION_R] == 1)
	{
		DrawGraph(0, 0, gr[10][2], true);
	}
	if (data[LOCATION_F1] == 0)
	{
		DrawGraph(0, 0, gr[11][2], true);
	}
	if (data[LOCATION_L] == 0)
	{
		DrawGraph(0, 0, gr[12][3], true);
	}
	if (data[LOCATION_R] == 0)
	{
		DrawGraph(0, 0, gr[13][1], true);
	}

こうなりました

あと、上記の処理の直前で dataの値をセットしているこちらですが

	for (int i = 0; i < LOCATION_MAX; i++) {
		data[i] = maps[Px + location[Pd][i][0]][Py + location[Pd][i][1]];
	}

正しくは

	for (int i = 0; i < LOCATION_MAX; i++) {
		data[i] = maps[Py + location[Pd][i][1]][Px + location[Pd][i][0]];
	}

こうではないでしょうか？( x と y を使う所が逆 )
maps の定義

int maps[ONE][ONE] = {
	{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
	{0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0},
	{0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0},
	{0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,0},
〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜

↑こちらの表の縦方向が２次元目、横方向が１次元目なので、maps[ ２次元目 ][ １次元目 ] つまり maps[ y ][ x ] なので
大抵 x と y は順番が x, y なので、[ y ][ x ]なのは何か気持ち悪いですが…

とりあえずこれで私の手元では正常な描画結果が得られるようになりました
メンテ
Re: 迷路について2 ( No.39 )
名前：FFGX（解決） 日時：2020/07/11 15:17 

ありがとうございました。
無事ゲームが完成しました。
メンテ

Page: 1 | 2 |

題名
名前
コメント
パスワード （記事メンテ時に使用）

   クッキー保存