public Dungeon GenDungeon(GenOptions opts)
{
this.opts = opts;
this.rooms.Clear();
this.corridors.Clear();
root = new BinaryNode(Point.Zero, Point.Zero, opts.DUN_WIDTH, opts.DUN_HEIGHT);
Divide(root);
GenRooms(root);
GenCorridors(root);
Tile[,] tiles = this.GenTiles();
var lastRoomGenned = this.rooms[this.rooms.Count - 1];
Point endPoint = lastRoomGenned.GetRandomPointInsideRoom(1);
tiles[endPoint.X, endPoint.Y].Type = TileType.End;
return(new Dungeon()
{
Tiles = tiles,
PlayerStartPos = this.rooms[0].GetRandomPointInsideRoom(1),
Rooms = rooms
});
}
public ModelRoot CreateTerrainMesh(HeightMap heightMap, GenOptions options = GenOptions.None, Matrix4x4 vectorTransform = default, bool doubleSided = true, float meshReduceFactor = 0.5f)
{
Triangulation triangulation = default;
if (options.HasFlag(GenOptions.BoxedBaseElevation0))
{
triangulation = _meshService.GenerateTriangleMesh_Boxed(heightMap, BoxBaseThickness.FixedElevation, 0);
}
else if (options.HasFlag(GenOptions.BoxedBaseElevationMin))
{
triangulation = _meshService.GenerateTriangleMesh_Boxed(heightMap, BoxBaseThickness.FromMinimumPoint, 5);
}
else
{
triangulation = _meshService.TriangulateHeightMap(heightMap);
}
triangulation = _meshReducer.Decimate(triangulation, meshReduceFactor);
// create a basic scene
var model = CreateNewModel();
var rnode = model.LogicalScenes.First()?.FindNode(n => n.Name == TERRAIN_NODE_NAME);
var rmesh = rnode.Mesh = model.CreateMesh(TERRAIN_MESH_NAME);
var material = model.CreateMaterial(string.Concat(TERRAIN_MESH_NAME, "Material"))
.WithPBRMetallicRoughness()
.WithDoubleSide(doubleSided);
var indexedTriangulation = new IndexedTriangulation(triangulation, vectorTransform);
// create mesh primitive
var primitive = rmesh.CreatePrimitive()
.WithVertexAccessor("POSITION", indexedTriangulation.Positions);
if (options.HasFlag(GenOptions.Normals))
{
var normals = _meshService.ComputeMeshNormals(indexedTriangulation.Positions, indexedTriangulation.Indices);
primitive = primitive.WithVertexAccessor("NORMAL", normals.ToList());
}
primitive = primitive.WithIndicesAccessor(PrimitiveType.TRIANGLES, indexedTriangulation.Indices)
.WithMaterial(material);
return(model);
}
public static Dungeon GenerateDungeon()
{
var bspGen = new BSPGenerator();
var genOpts = new GenOptions()
{
DUN_WIDTH = 50 + level * 10,
DUN_HEIGHT = 50 + level * 10,
MAX_LEAF_AREA = 650,
MIN_LEAF_SIDE = 10,
MIN_ROOM_SIDE = 6
};
Dungeon dungeon = bspGen.GenDungeon(genOpts);
SpawnMonsters(dungeon);
return(dungeon);
}
public async Task <string> Gen(CodeClass selectedClass, GenOptions opts)
{
_opts = opts;
_genner = new ClassGenerator(_parts, _opts, _dte);
if (_debugMode == true)
{
ParseFunctions(selectedClass);
return(PutItAllTogether());
}
else
{
return(await Task.Run(() =>
{
ParseFunctions(selectedClass);
return PutItAllTogether();
}));
}
}
void DebugStart()
{
var lvlGen = new BSPGenerator();
var genOpts = new GenOptions()
{
DUN_WIDTH = 50,
DUN_HEIGHT = 50,
MAX_LEAF_AREA = 650,
MIN_LEAF_SIDE = 10,
MIN_ROOM_SIDE = 6
};
Dungeon dungeon = lvlGen.GenDungeon(genOpts);
this.LeveMng.LoadLevel(dungeon);
SetupPlayer(dungeon.PlayerStartPos, this.PlayerTestBuild);
// Room room = dungeon.Rooms[0];
// Point dogStartPos = dungeon.PlayerStartPos;
// dogStartPos.Y++;dogStartPos.Y++;dogStartPos.Y++;
//// while(true)
//// {
//// dogStartPos = room.GetRandomPointInsideRoom(1);
//// if (dogStartPos != dungeon.PlayerStartPos)
//// {
//// break;
//// }
//// }
for (int i = 0; i < dungeon.Rooms.Count; i++)
{
var room = dungeon.Rooms[i];
var dogGo = (GameObject)Instantiate(this.DogPrefab);
var dog = dogGo.GetComponent <Monster>();
this.LeveMng.AddCharacterOnPos(dog as Character, room.GetRandomPointInsideRoom(2));
}
LevelMng.Instance.ActivateRoom(dungeon.Rooms[0]);
}
void Build(bool bUnInitData = false)
{
GenOptions genOpt = GenOptions.None;
if (m_bGenNewVersion)
{
genOpt = genOpt | GenOptions.bGenVersion;
}
if (m_bBundleLua)
{
genOpt = genOpt | GenOptions.bBundleLua;
}
if (m_bBundleMap)
{
genOpt = genOpt | GenOptions.bBundleMap;
}
if (m_bBundleData)
{
genOpt = genOpt | GenOptions.bBundleUI;
}
//if (m_bBundleUI) genOpt = genOpt | GenOptions.bBundleUI;
//if (m_bBundleChar) genOpt = genOpt | GenOptions.bBundleChar;
//if (m_bBundleObj) genOpt = genOpt | GenOptions.bBundleObj;
//if (m_bBundleEff) genOpt = genOpt | GenOptions.bBundleEff;
//if (m_bBundleMedia) genOpt = genOpt | GenOptions.bBundleMedia;
if (m_bPackage)
{
genOpt = genOpt | GenOptions.bPackage;
}
if (m_bBuildApp)
{
genOpt = genOpt | GenOptions.bBuildApp;
}
if (m_bCopyBundle)
{
genOpt = genOpt | GenOptions.bCopyBundle;
}
if (m_bCopyWinRsrc)
{
genOpt = genOpt | GenOptions.bCopyWinRsrc;
}
//Release版本
BuildOptions buildOptions = BuildOptions.None;
if (m_nBuildSelect == 0)
{
buildOptions = BuildOptions.Development | BuildOptions.ConnectWithProfiler | BuildOptions.AllowDebugging; // debug
}
else
{
buildOptions = BuildOptions.None; // release
}
//平台工程
if (m_bBuildProject && AppPackage.ms_target == BuildTarget.Android)
{
buildOptions = buildOptions | BuildOptions.AcceptExternalModificationsToPlayer;
}
else if (m_bBuildProject && AppPackage.ms_target == BuildTarget.iOS)
{
buildOptions = buildOptions | BuildOptions.AcceptExternalModificationsToPlayer | BuildOptions.Il2CPP;
}
PackageScatteredApp.Build(m_sNewVersion, m_BuildTarget, buildOptions, genOpt, bUnInitData);
m_sOldVersion = PackageScatteredApp.ms_sVersion;
}
public IEnumerable <string> Build(Grammar grammar, GenOptions options)
{
this.report = new GrammarReport <int, object>();
this.grammar = grammar;
this.precedenceTable = new PrecedenceTable <int>(grammar.SymbolsRep);
this.functionsRegistry = new FunctionRegistry();
transformMultiplications();
try
{
createRules();
if (grammar.PostValidate(s => report.AddError(s), s => report.AddWarning(s)))
{
createPrecedences();
}
}
catch (ParseControlException ex)
{
Console.WriteLine(ex.Message);
return(null);
}
catch (Exception ex)
{
Console.WriteLine("Error while building parser: " + ex.Message);
Console.WriteLine(ex.StackTrace);
return(null);
}
Productions <int, object> productions = productionBuilder.GetProductions(grammar.GetSymbolId(Grammar.EOFSymbol),
grammar.GetSymbolId(Grammar.ErrorSymbol), report);
if (report.HasGrammarErrors)
{
Console.WriteLine(String.Join(Environment.NewLine, report.ReportGrammarProblems()));
return(null);
}
else
{
ActionTable <int, object> action_table = ParserFactory.CreateActionTable(productions, precedenceTable, report, lookaheadWidth);
if (action_table == null)
{
if (!options.NoOutput)
{
Console.WriteLine("Grammar has errors, reports were written " + report.WriteReports("report_"));
}
return(null);
}
else
{
if (options.ReportOther)
{
Console.WriteLine("Reports were written " + report.WriteReports("report_"));
}
return(buildNamespaceHeader(grammar)
.Concat(buildClassHeader(grammar.ParserTypeInfo))
.Concat(buildRules(action_table, grammar.TokenTypeInfo,
(id => grammar.TokenTypeInfo.FieldNameOf(grammar.GetSymbolName(id))), grammar.TreeNodeName))
.Concat(buildClassFooter())
.Concat(buildNamespaceFooter())
);
}
}
}
public ClassGenerator(UnitTestParts parts, GenOptions opts, DTE2 dte)
{
_opts = opts;
_parts = parts ?? new UnitTestParts();
_dte = dte;
}
