private void CreateRooms()
{
var roomsList = ProceduralGenerationAlgorithms.BinarySpacePartitioning(new BoundsInt((Vector3Int)startPos, new Vector3Int(dungeonWidth, dungeonHeight, 0)),
minRoomWidth, minRoomHeight); // divide the dungeon into multiple rooms
HashSet <Vector2Int> floor = new HashSet <Vector2Int>();
if (randomWalkRooms)
{
floor = CreateRoomsRandomly(roomsList); // create rooms with randomwalk using the divided rooms provided
}
else
{
floor = CreateSimpleRooms(roomsList); // create simple rooms using the divided rooms provided
}
List <Vector2Int> roomCenters = new List <Vector2Int>();
foreach (var room in roomsList)
{
roomCenters.Add((Vector2Int)Vector3Int.RoundToInt(room.center)); // get the center of each room and add it to roomCenters
}
HashSet <Vector2Int> corridors = ConnectRooms(roomCenters);
floor.UnionWith(corridors);
tilemapVisualizer.PaintFloorTile(floor);
WallGenerator.CreateWall(floor, tilemapVisualizer);
}
private void CreateRooms()
{
var roomsList = ProceduralGenerationAlgorithms.BinarySpacePartitioning(new BoundsInt((Vector3Int)startPosition, new Vector3Int(dungeonWidth, dungeonHeight, 0)), minRoomWidth, minRoomHeight);
HashSet <Vector2Int> floor = new HashSet <Vector2Int>();
if (randomWalkRooms)
{
floor = CreateRoomsRandomly(roomsList);
}
else
{
floor = CreateSimpleRooms(roomsList);
}
List <Vector2Int> roomCenters = new List <Vector2Int>();
foreach (var room in roomsList)
{
roomCenters.Add((Vector2Int)Vector3Int.RoundToInt(room.center));
}
HashSet <Vector2Int> corridors = ConnectRooms(roomCenters);
floor.UnionWith(corridors);
tilemapVisualizer.PaintFloorTiles(floor);
WallGenerator.CreateWalls(floor, tilemapVisualizer);
}
// Use this for initialization
void Awake()
{
_3DRoot = GameObject.Find("3D Root");
wallGenerator = _3DRoot.GetComponent <WallGenerator>();
isoCam = _3DRoot.transform.Find("Isocam").gameObject as GameObject;
player = _3DRoot.transform.Find("Player").gameObject as GameObject;
_3DRoot.SetActive(false);
_2DRoot = GameObject.Find("2D Root");
wallManager = GameObject.Find("2DManager").GetComponent <WallManager>();
//_2DRoot = GameObject.Find("2D Root");
//_3DRoot = GameObject.Find("3D Root");
mainMenuScrollView = GameObject.Find("Main Menu Scroll View");
submenu = GameObject.Find("Sub Menu");
itemNames = new string[] { "windows & door", "table", "bed", "chair" };
windowsanddoorNames = new string[] { "door1", "door2", "window1", "window2" };
tableNames = new string[] { "simple", "square", "long", "side", "oval", "stylish", "metallic", "coffeetop" };
//cupboardNames = new string[] { "wooden", "metal", "glass", "circle" };
bedNames = new string[] { "simple", "lowered", "side-table", "double-table" };
chairNames = new string[] { "red", "wooden", "round" };
_3DUIRoot = transform.Find("3D UI Root");
_2DUIRoot = transform.Find("2D UI Root");
_3DUIRoot.gameObject.SetActive(false);
}
protected override void RunProcedualGeneration()
{
HashSet <Vector2Int> floorPositions = RunRandomWalk(randomWalkParameters, startPos);
tilemapVisualizer.Clear();
tilemapVisualizer.PaintFloorTile(floorPositions);
WallGenerator.CreateWall(floorPositions, tilemapVisualizer);
}
void Start()
{
WallGenerator.execute();
textController = GetComponent <TextController>();
count = 0f;
startCount = 0f;
is_finished = false;
}
protected override void RunProceduralGeneration()
{
HashSet <Vector2Int> floorPosition = RunRandomWalk(randomWalkParamiters, startPos);
tileMapVisualiser.Clear();
tileMapVisualiser.paintFloorTile(floorPosition);
WallGenerator.CreateWalls(floorPosition, tileMapVisualiser);
}
public void Init()
{
_floorSpace = new FacilitySpace {
Ground = new FacilityObject {
Type = FacilityObjectNames.Floor
}
};
_wallGenerator = new WallGenerator();
}
/// <summary>
/// (Re)Instantiates Rooms and Wall objects
/// </summary>
public void InstantiateAll()
{
InstantiateParent(ref roomParent, "Rooms");
InstantiateParent(ref wallParent, "Walls");
GameObject[][,] wallGroups = WallGenerator.InstantiateWalls(wallParent.transform, wallPrefab, n, radius);
GameObject[,] rooms = RoomGenerator.InstantiateRooms(roomParent.transform, roomPrefab, radius);
for (int i = 0; i < wallGroups.Length; i++)
{
float angle = WallGenerator.CalculateRotation(i, n) * Mathf.Deg2Rad;
for (int roomY = 0; roomY < rooms.GetLength(1); roomY++)
{
int offset = -Mathf.Max(radius - roomY - 1, 0);
for (int roomX = Mathf.Max(radius - roomY - 1, 0); roomX < rooms.GetLength(0); roomX++)
{
GameObject go = rooms[roomX, roomY];
if (go != null)
{
RoomController room = go.GetComponent <RoomController>();
if (i == 0)
{
WallController w1 = wallGroups[i][roomX + offset, roomY].GetComponent <WallController>();
WallController w2 = wallGroups[i][roomX + offset + 1, roomY].GetComponent <WallController>();
AddWalls(room, w1, w2);
}
else
{
Vector2 roomPosition = new Vector2(room.transform.position.x, room.transform.position.z);
Vector2 rotatedPosition = roomPosition.RotateAround(0f, 0f, angle);
if (TryGetGameObjectAtPosition(rooms, new Vector3(rotatedPosition.x, 0f, rotatedPosition.y), out GameObject targetRoom))
{
RoomController target = targetRoom.GetComponent <RoomController>();
WallController w1 = target.Walls[0], w2 = target.Walls[1];
w1 = wallGroups[i][w1.X, w1.Y].GetComponent <WallController>();
w2 = wallGroups[i][w2.X, w2.Y].GetComponent <WallController>();
AddWalls(room, w1, w2);
}
else
{
Debug.Log($"Couldn't find room at position {rotatedPosition}");
}
}
}
}
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
WallGenerator script = (WallGenerator)target;
if (GUILayout.Button("Rebuild"))
{
script.Generate();
}
}
public override void OnInspectorGUI()
{
WallGenerator wallGenerator = target as WallGenerator;
DrawDefaultInspector();
if (GUILayout.Button("Generate Wall"))
{
wallGenerator.GenerateWall();
}
}
void Start()
{
rooms = GetComponent <RoomGenerator>();
corridors = GetComponent <CorridorGenerator>();
walls = GetComponent <WallGenerator>();
chests = GetComponent <ChestGenerator>();
playerAndMerchantsGenerator = GetComponent <PlayerAndMerchantsGenerator>();
enemiesGenerator = GetComponent <EnemiesGenerator>();
StartCoroutine(CreateDungeon());
//
}
public Level(int width, int height)
{
this.width = width;
this.height = height;
tileObservers = new List <ITileObserver>();
wallObservers = new List <IWallObserver>();
furnitureObservers = new List <IFurnitureObserver>();
tiles = TileGenerator.Generate(this, width, height);
walls = WallGenerator.Generate(this, width, height);
characters = new List <ICharacter>();
}
// Initializes tile as existing or nonexisting color based on its initial value.
private void Start()
{
wallUnitUI = gameObject.GetComponent <Image>();
wallGenerator = GameObject.Find("WallGenerator").GetComponent <WallGenerator>();
if (unitExistenceArrayValue == 1)
{
ExistingWallUnit();
}
else
{
NonexistingWallUnit();
}
}
private void CorridorFirstGeneration()
{
HashSet <Vector2Int> floorPositions = new HashSet <Vector2Int>();
HashSet <Vector2Int> potentialRoomPositions = new HashSet <Vector2Int>();
CreateCorridoor(floorPositions, potentialRoomPositions);
HashSet <Vector2Int> roomPositions = CreateRooms(potentialRoomPositions);
List <Vector2Int> deadEnds = FindAllDeadEnd(floorPositions);
CreateRoomAtDeadEnd(deadEnds, roomPositions);
floorPositions.UnionWith(roomPositions); // save both corridor and room floor
tilemapVisualizer.PaintFloorTile(floorPositions);
WallGenerator.CreateWall(floorPositions, tilemapVisualizer);
}
public void SetWall(WallGenerator wall)
{
Controller.enabled = false;
Input = GetComponent <PlayerInput>();
this.wall = wall;
var end = wall.GetComponentInChildren <EndSequence>();
cameraPos = Camera.transform.localPosition;
cameraRot = Camera.transform.localRotation;
spawnPoint = GameManager.Instance.GetSpawnPoint(Input);
transform.SetPositionAndRotation(spawnPoint.position, spawnPoint.rotation);
Camera.transform.position = end.cameraPoint.position;
Camera.transform.rotation = end.cameraPoint.rotation;
lookRotation.y = transform.rotation.eulerAngles.y;
GrabPoint.SetColor(Input.playerIndex);
}
public Match(string seed, IEnumerable<string> accountIds, int lobby, MatchType matchType, LogOnService logOnService)
{
_lobby = lobby;
_matchType = matchType;
_logOnService = logOnService;
_shuffler = new WallGenerator(seed);
_firstOyaIndex = _shuffler.GetWall(0).First().Id % 4;
var playerIndex = 0;
foreach (var player in accountIds)
{
_players.Add(player, new PlayerStatus(playerIndex));
playerIndex += 1;
}
_stateMachine = new StateMachine(new PlayersConnectingState(this));
_stateMachine.Finished += OnFinished;
}
private void CorridorFirstGeneration()
{
HashSet <Vector2Int> floorPositions = new HashSet <Vector2Int>();
HashSet <Vector2Int> potentialRoomPositions = new HashSet <Vector2Int>();
CreateCorridors(floorPositions, potentialRoomPositions);
HashSet <Vector2Int> roomPositions = CreateRooms(potentialRoomPositions);
List <Vector2Int> deadEnds = FindAllDeadEnds(floorPositions);
CreateRoomsAtDeadEnds(deadEnds, roomPositions);
floorPositions.UnionWith(roomPositions);
tileMapVisualiser.paintFloorTile(floorPositions);
WallGenerator.CreateWalls(floorPositions, tileMapVisualiser);
}
/// <summary>
/// 初期化
/// </summary>
private void Initialize()
{
// ポーズパネルを非表示
PausePanel.SetActive(false);
// enemyGeneratorのnullチェック
if (enemyGenerator != null)
{
// enemyGeneratorのコンポーネントを取得
enemyGenerator = enemyGenerator.GetComponent <EnemyGenerator>();
}
// wallGeneratorのnullチェック
else if (wallGenerator != null)
{
// wallGeneratorのコンポーネントを取得
wallGenerator = wallGenerator.GetComponent <WallGenerator>();
}
}
//generates track and stores those objects
public void generate(string code)
{
string[] track; //track variable information
//initializing compiler and compiling code.//
Compiler.setCode(code);
Compiler.compile();
//interpretor setup and initilisation//
_ip = new Interpretor();
_ip.setICode(Compiler.getICode());
_ip.init();
rg = new WallGenerator(this);
path = new GameObject("path");
rg.setPath(path);
//parse the whole code.
Compiler.setCode(code);
if (!(Compiler.compile()))
{
return;
}
//Debug.Log("track generation sarted-------------------");
//Debug.Log("s:" + speed_points + ",p:" + points_per_track);
//each track instruction is provided
while ((track = _ip.nextIns()) != null)
{
string __st = track[0];
if (__st == Compiler.EOP)
{
break;
}
else if (__st == "wall")
{
wallFunc(track);
}
}
load();
}
private void GameEnded()
{
WallGenerator winner = null;
float bestScore = -1;
foreach (WallGenerator wall in _walls)
{
float score = wall.GetScore();
if (score > bestScore)
{
bestScore = score;
winner = wall;
}
}
if (activePlayers.Count > 1 || bestScore >= minimumSPWinThreshold)
{
winner.IsWinningPlayer = true;
}
OnGameFinished?.Invoke();
}
public static void Execute(Beatmap beatmap)
{
try
{
var tuples = new List <Tuple <string, string, List <KeyValuePair <string, string> > > >();
groupYmlContextLines(readAllLinesFromFile(beatmap.FullPath.Replace(".dat", ".yml")), tuples, beatmap.SongInfo.FullFolderPath);
var walls = new List <ObjectData>();
var events = new List <EventData>();
var firstTuple = tuples.First();
if (firstTuple.Item1.Invariant("default"))
{
var defaultGenerator = new WallGenerator();
var generatorList = new List <WallGenerator>();
Global.Instance.Logger.Info("Setting all generators");
setGenerators(tuples, generatorList, defaultGenerator);
var wallList = new List <Wall>();
var eventList = new List <Event>();
Global.Instance.Logger.Info("Generating nodes");
foreach (var wallGenerator in generatorList)
{
wallList.AddRange(wallGenerator.GenerateWallsFinalized());
eventList.AddRange(wallGenerator.GenerateEventsFinalized());
}
Global.Instance.Logger.Info("Converting nodes to objects");
walls.AddRange(wallList.Select(t => t.GenerateObstacle()).OrderBy(t => t.Time));
events.AddRange(eventList.SelectMany(t => t.GenerateEvent()).OrderBy(t => t.Time));
if (defaultGenerator.FlipOuterProps)
{
var eventsChanged = new int[5][] { new int[2] {
0, 0
}, new int[2] {
0, 0
}, new int[2] {
0, 0
}, new int[2] {
0, 0
}, new int[2] {
0, 0
} };
for (var i = 0; i <= 4; i++)
{
var highestProp = (int)defaultGenerator.GetType().GetProperties().First(f => f.Name.Invariant($"HighestProp{i}")).GetValue(defaultGenerator);
var lowestProp = (int)defaultGenerator.GetType().GetProperties().First(f => f.Name.Invariant($"LowestProp{i}")).GetValue(defaultGenerator);
var evHigh = events.Where(t => t.Type == i && t.CustomData.PropID == highestProp).ToArray();
var evLow = events.Where(t => t.Type == i && t.CustomData.PropID == lowestProp).ToArray();
foreach (var ev in events)
{
if (ev.Type == i && ev.CustomData.PropID == highestProp)
{
ev.CustomData.PropID = lowestProp;
eventsChanged[i][0]++;
}
else if (ev.Type == i && ev.CustomData.PropID == lowestProp)
{
ev.CustomData.PropID = highestProp;
eventsChanged[i][1]++;
}
}
}
Global.Instance.Logger.Info($"Changed {eventsChanged.SelectMany(t => t).Sum()} events where:{Environment.NewLine}{string.Join(Environment.NewLine, eventsChanged.Select((t, i) => $"{i} type had {t[0]} highs changed and {t[1]} lows changed."))}");
}
}
else if (firstTuple.Item1.Invariant("mergeFiles"))
{
var jObjects = new List <JObject>();
foreach (var file in firstTuple.Item3.Find(t => t.Key.Invariant("files")).Value.Split(','))
{
jObjects.Add(JObject.Parse(File.ReadAllText(Path.Combine(beatmap.SongInfo.FullFolderPath, file))));
}
foreach (var fileJObject in jObjects)
{
var eventObjects = fileJObject["_events"].ToEvent();
var eventOverlap = eventObjects.Where(e => events.Any(es => e.Time.Within(es.Time, timeConst))).ToArray();
if (eventOverlap.Length > 0)
{
foreach (var overlappedEvent in eventOverlap)
{
Global.Instance.Logger.Log(LogLevel.Warn, $"Found event overlap with constraint of {timeConst} event data:{overlappedEvent}");
}
}
eventObjects.CheckZoomCountEven();
events.AddRange(eventObjects);
}
}
var jObject = JObject.Parse(File.ReadAllText(beatmap.FullPath));
var oldObstaclesPath = getOldPath(beatmap, "Obstacles");
var oldEventsPath = getOldPath(beatmap, "Events");
if (walls.Any())
{
Global.Instance.Logger.Info("Writing wall objects and storing old objects");
using (var s = File.OpenWrite(Path.Combine(oldObstaclesPath, $"{DateTime.Now:yy-MM-dd hh.mm.ss}.obstacles.json")))
using (var sw = new StreamWriter(s))
using (var writer = new JsonTextWriter(sw))
{
var serializer = new JsonSerializer {
Formatting = Formatting.None
};
serializer.Serialize(writer, jObject["_obstacles"]);
}
jObject["_obstacles"] = walls.ToJArray();
}
if (events.Any())
{
Global.Instance.Logger.Info("Writing event objects and storing old objects");
using (var s = File.OpenWrite(Path.Combine(oldEventsPath, $"{DateTime.Now:yy-MM-dd hh.mm.ss}.events.json")))
using (var sw = new StreamWriter(s))
using (var writer = new JsonTextWriter(sw))
{
var serializer = new JsonSerializer {
Formatting = Formatting.None
};
serializer.Serialize(writer, jObject["_events"]);
}
jObject["_events"] = events.ToJArray();
}
beatmap.EventCount = jObject["_events"].Children().Count();
beatmap.ObstacleCount = jObject["_obstacles"].Children().Count();
beatmap.NoteCount = jObject["_notes"].Children().Count();
Global.Instance.Logger.Info("Writing finalized file");
using (var s = File.OpenWrite(beatmap.FullPath))
using (var sw = new StreamWriter(s))
using (var writer = new JsonTextWriter(sw))
{
var serializer = new JsonSerializer {
Formatting = Formatting.None
};
serializer.Serialize(writer, jObject);
}
}
catch (Exception e)
{
Global.Instance.Logger.Error(e, e.Message);
}
Global.Instance.Logger.Info($"Compleated Run {++beatmap.GenCount} of {beatmap.SongInfo.SongName}, {beatmap.Difficulty}{beatmap.BeatmapSet.CharacteristicString}");
}
void Awake()
{
bluePos = new List <Vector2Int>();
orangePos = new List <Vector2Int>();
size = new Vector2Int();
List <string> rows = new List <string>();
StreamReader sr = new StreamReader(Application.dataPath + "/" + mapFile);
string line = sr.ReadLine();
while (line != null)
{
rows.Add(line);
if (line.Length > size.x)
{
size.x = line.Length;
}
line = sr.ReadLine();
}
rows.Reverse();
size.y = rows.Count;
offset = new Vector2Int(-size.x / 2, -size.y / 2);
grid = new byte[size.y][];
pellets = new GameObject[size.y][];
waller = GetComponent <WallGenerator>();
waller.SetUp(size);
for (int i = 0; i < size.y; ++i)
{
grid[i] = new byte[size.x];
pellets[i] = new GameObject[size.x];
for (int j = 0; j < rows[i].Length; ++j)
{
byte val = translateChar(rows[i][j]);
grid[i][j] = val;
Vector3 ip = new Vector3(j + offset.x, i + offset.y, 0);
GameObject obj = (GameObject)Instantiate(lookup[val], ip, Quaternion.identity, transform);
switch (val)
{
case 1:
pellets[i][j] = obj;
break;
case 2:
pellets[i][j] = obj;
break;
case 3:
bluePos.Add(new Vector2Int(j, i));
break;
case 4:
orangePos.Add(new Vector2Int(j, i));
break;
case 5:
waller.AddWall(i, j, obj.GetComponent <Wall>());
break;
}
}
for (int j = rows[i].Length; j < size.x; ++j)
{
grid[i][j] = 0;
}
}
waller.Build();
}
private void Awake()
{
wall = GetComponentInParent <WallGenerator>();
}
private static void setGenerators(List <Tuple <string, string, List <KeyValuePair <string, string> > > > tuples, List <WallGenerator> generatorList, WallGenerator defaultGenerator)
{
var structures = new Dictionary <string, WallGenerator>();
var rotationModes = new Dictionary <string, IRotationMode>();
var colorModes = new Dictionary <string, ColorManager>();
foreach (var(identifier, type, list) in tuples)
{
if (type == "")
{
var seed = Convert.ToInt32(list.First(t => t.Key.Invariant("seed")).Value);
defaultGenerator.Random = new Random(seed);
foreach (var(key, value) in list)
{
if (!key.Invariant("seed"))
{
setFieldValue(defaultGenerator, key, value, null, null, null, null);
}
}
}
else if (identifier.Invariant("rotationMode"))
{
var local = false;
var multi = false;
var localRotList = new List <Tuple <Vector3D, double> >();
var rotList = new List <Tuple <Vector3D, double> >();
dynamic rotationStore = new NoRotation();
foreach (var(key, value) in list)
{
if (key.Invariant("localrotation"))
{
local = true;
if (value == "")
{
multi = true;
continue;
}
}
else if (key.Invariant("rotation"))
{
local = false;
if (value == "")
{
multi = true;
continue;
}
}
if (key.Invariant("type"))
{
rotationStore = value.ToLowerInvariant() switch
{
"static" => new StaticRotation(),
"ease" => new EaseRotation(),
"random" => new RandomRotation(),
"switch" => new SwitchRotation(),
_ => throw new ArgumentOutOfRangeException("Rotation type can only be of types: Static, Ease, Random, Switch")
}
}
;
else if (key.Invariant("ease"))
{
rotationStore.Easing = value.GetEasing();
}
else
{
if (multi)
{
switch (rotationStore)
{
case EaseRotation _:
var vector = value.Substring(0, value.LastIndexOf(','));
var time = Convert.ToDouble(value.Substring(value.LastIndexOf(',') + 1));
if (local)
{
localRotList.Add(new Tuple <Vector3D, double>(Vector3D.Parse(vector), time));
}
else
{
rotList.Add(new Tuple <Vector3D, double>(Vector3D.Parse(vector), time));
}
break;
case RandomRotation _:
if (local)
{
localRotList.Add(new Tuple <Vector3D, double>(Vector3D.Parse(value), 0));
}
else
{
rotList.Add(new Tuple <Vector3D, double>(Vector3D.Parse(value), 0));
}
break;
case SwitchRotation _:
if (local)
{
localRotList.Add(new Tuple <Vector3D, double>(Vector3D.Parse(value), 0));
}
else
{
rotList.Add(new Tuple <Vector3D, double>(Vector3D.Parse(value), 0));
}
break;
}
}
else
{
if (local)
{
rotationStore.LocalRotation = Vector3D.Parse(value);
}
else
{
rotationStore.Rotation = Vector3D.Parse(value);
}
}
}
}
switch (rotationStore)
{
case EaseRotation easeStore:
easeStore.LocalRotations = localRotList.ToArray();
easeStore.Rotations = rotList.ToArray();
break;
case RandomRotation randomStore:
randomStore.LocalRotation = new Tuple <Vector3D, Vector3D>(localRotList[0].Item1, localRotList[1].Item1);
randomStore.Rotation = new Tuple <Vector3D, Vector3D>(rotList[0].Item1, rotList[1].Item1);
break;
case SwitchRotation switchStore:
switchStore.LocalRotations = localRotList.Select(t => t.Item1).ToArray();
switchStore.Rotations = rotList.Select(t => t.Item1).ToArray();
break;
}
try
{
rotationModes.Add(type, rotationStore);
}
catch (Exception e)
{
Global.Instance.Logger.Error($"Could not add rotationMode name: {type}, as it already exists");
throw e;
}
}
public void TestWallGenerator()
{
var w = new WallGenerator(Seed);
Assert.AreEqual(5, w.GetDice(0).ToList()[0], "dice 0");
Assert.AreEqual(5, w.GetDice(0).ToList()[1], "dice 1");
Assert.AreEqual(11, w.GetWall(0).ToList()[5].Id, "dora 0");
Assert.IsTrue(_tileIdsGame0.SequenceEqual(w.GetWall(0).Select(t => t.Id).Reverse().Take(13 * 4)), "wall");
Assert.AreEqual(1, w.GetDice(1).ToList()[0], "dice 0");
Assert.AreEqual(3, w.GetDice(1).ToList()[1], "dice 1");
Assert.AreEqual(109, w.GetWall(1).ToList()[5].Id, "dora 0");
Assert.IsTrue(_tileIdsGame1.SequenceEqual(w.GetWall(1).Select(t => t.Id).Reverse().Take(13 * 4)), "wall");
}
