private string MapToAbstract()
{
List <AbstractLevel> levels = new List <AbstractLevel>();
for (int levelIndex = 0; levelIndex < allLevels.Count - 1; levelIndex++)
{
List <OverworldNode> thisLevel = allLevels[levelIndex];
List <OverworldNode> nextLevel = allLevels[levelIndex + 1];
AbstractLevel lvl = LevelToAbstract(thisLevel, nextLevel);
lvl.numNodes = thisLevel.Count;
levels.Add(lvl);
}
AbstractLevel finallvl = LevelToAbstract(allLevels[allLevels.Count - 1], null);
finallvl.numNodes = 1;
levels.Add(finallvl);
AbstractMap map = new AbstractMap();
map.numLevels = allLevels.Count;
map.levels = levels;
Tuple <int, int> playerPos = FindPlayerAt();
if (playerPos != null)
{
map.playerLevel = playerPos.Item1;
map.playerNode = playerPos.Item2;
}
return(JsonUtility.ToJson(map));
}
public static void Initialise(MonoGameRenderer renderer)
{
//levelCompleteState = new LevelCompleteState(nextLevelState);
//nextLevelState = new NextLevelState(levelInProgressState);
collusionManager = new CollusionManager();
level = new LevelOne(null, collusionManager);
character = new Character(level, collusionManager);
gameInProgressState = new GameInProgressState(initialState, level, character);
drawCompleteState = new DrawCompleteState(initialState);
drawCharacterState = new DrawCharacterState(initialState, character);
drawLevelState = new DrawLevelState(initialState, level);
drawLevelBuilderState = new DrawLevelBuilderState(initialState);
drawMainMenuState = new DrawMainMenuState(initialState);
initialState = new InitialState(drawMainMenuState);
//displayMainMenuState.NextState = displayLevelBuilderState;
//displayLevelBuilderState.NextState = initialState;
//displayLevelState.NextState = initialState;
//levelInProgressState.NextState = levelCompleteState;
//levelCompleteState.NextState = nextLevelState;
//nextLevelState.NextState = levelInProgressState;
States.Add("InitialState", initialState);
States.Add("DrawMainMenuState", drawMainMenuState);
States.Add("DrawLevelBuilderState", drawLevelBuilderState);
States.Add("DrawLevelState", drawLevelState);
States.Add("DrawCharacterState", drawCharacterState);
States.Add("DrawCompleteState", drawCompleteState);
States.Add("GameInProgressState", gameInProgressState);
//States.Add("LevelCompleteState", levelCompleteState);
//States.Add("NextLevelState", nextLevelState);
}
private AbstractLevel LevelToAbstract(List <OverworldNode> level, List <OverworldNode> next)
{
AbstractLevel lvl = new AbstractLevel();
lvl.numNodes = level.Count;
lvl.nodes = new List <AbstractNode>();
if (next != null)
{
foreach (OverworldNode node in level)
{
AbstractNode absnode = new AbstractNode();
absnode.links = new List <int>();
foreach (OverworldNode other in node.outwardLinks)
{
int otherindex = next.FindIndex((a) => { return(a == other); });
absnode.links.Add(otherindex);
}
lvl.nodes.Add(absnode);
}
}
return(lvl);
}
public Character(AbstractLevel level, CollusionManager collusionManager)
{
Level = level;
CurrentPositionX = Level.BoundaryLeft;
CurrentPositionY = Level.BoundaryBottom - Height;
PreviousPositionX = CurrentPositionX;
PreviousPositionY = CurrentPositionY;
this.collusionManager = collusionManager;
AddCollider();
}
private void AbstractToMap(string abstractMap)
{
ClearLevel();
AbstractMap absMap = JsonUtility.FromJson <AbstractMap>(abstractMap);
rootPosition = new Vector3((NumberOfLevels - 1) * distanceBetweenLevels * -0.5f, 0, 0);
Vector3 pos = rootPosition;
//generate all levels
NumberOfLevels = absMap.numLevels;
foreach (AbstractLevel absLevel in absMap.levels)
{
List <OverworldNode> level = CreateLevel(absLevel.numNodes, pos);
pos.x += distanceBetweenLevels;
allLevels.Add(level);
}
//link all nodes
for (int i = 0; i < NumberOfLevels - 1; i++)
{
AbstractLevel absLevel = absMap.levels[i];
List <OverworldNode> leftLevel = allLevels[i];
List <OverworldNode> rightLevel = allLevels[i + 1];
for (int nodeId = 0; nodeId < absLevel.numNodes; nodeId++)
{
AbstractNode absNode = absLevel.nodes[nodeId];
OverworldNode leftNode = leftLevel[nodeId];
foreach (int link in absNode.links)
{
OverworldNode rightNode = rightLevel[link];
LinkNodes(leftNode, rightNode);
}
}
}
SetPlayerAt(allLevels[absMap.playerLevel][absMap.playerNode]);
}
void SetLevel()
{
if (lgo != null)
{
GameObject.Destroy(lgo);
lgo = null;
}
var level = _levelNames[_currentLevel];
var subDir = $"Levels/{level}";
var goPath = $"{subDir}/Level{level}";
Debug.Log($"Instantiating {goPath}");
{
var go = Resources.Load <GameObject>(goPath);
if (go == null)
{
throw new Exception($"failed to load resource '{goPath}'");
}
lgo = Instantiate(go);
}
Level = (AbstractLevel)lgo?.GetComponent <MonoBehaviour>();
if (Level == null)
{
throw new Exception($"failed to find component for level '{level}'");
}
if (audioSource != null)
{
audioSource.Stop();
}
audioSource = lgo.GetComponent <AudioSource>();
if (audioSource != null)
{
audioSource.Play();
}
var bgcam = GameObject.Find("Background Camera").GetComponent <Camera>();
bgcam.backgroundColor = Level.clearColor;
var bggo = GameObject.Find("BackgroundPlane");
bggo.GetComponent <MeshRenderer>().material = Level.backgroundMaterial;
_currentLevel = ++_currentLevel % _levelNames.Length;
// update current visuals:
foreach (var c in Playfield.GetEnumeratorCells())
{
InstantiateVisual(c);
}
foreach (var s in Playfield.GetEnumeratorSquares())
{
// InstantiateVisual(s);
}
var dpv = GameObject.Find("DropPiece").GetComponent <DropPieceView>();
dpv.UpdateVisuals = true;
}
public DrawLevelState(State nextState, AbstractLevel level)
: base(nextState)
{
this.level = level;
}
public GameInProgressState(State nextState, AbstractLevel level, Character character)
: base(nextState)
{
this.level = level;
this.character = character;
}
void CreateLevel(bool fragmentBased)
{
if (string.IsNullOrWhiteSpace(_levelName))
{
EditorUtility.DisplayDialog("Level name required", "Please fill in the 'Level Name' field before creating a level", "OK");
return;
}
AssetDatabase.CreateFolder("Assets/Resources/Levels", _levelName);
var blackPath = CopyItem(!string.IsNullOrWhiteSpace(_blackImagePath) ? _blackImagePath : "Black.png", "Black.png");
CopyItem("Black.prefab");
var whitePath = CopyItem(!string.IsNullOrWhiteSpace(_whiteImagePath) ? _whiteImagePath : "White.png", "White.png");
CopyItem("White.prefab");
var shaderNameOnly = "";
if (!string.IsNullOrEmpty(_shaderPath))
{
shaderNameOnly = System.IO.Path.GetFileName(_shaderPath);
CopyItem(_shaderPath, shaderNameOnly);
}
var shaderPath = SaveTemplateFile(new T4Generator.ShaderTemplate(_levelName, shaderNameOnly).TransformText(), "LevelTemplate.shader");
// import copied assets:
Debug.Log("updating resources...");
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
// create material from shader:
var shaderImporter = (ShaderImporter)AssetImporter.GetAtPath(shaderPath);
var newMaterial = new Material(shaderImporter.GetShader());
AssetDatabase.CreateAsset(newMaterial, shaderPath.Replace(".shader", ".mat"));
// reset level name:
_levelName = "";
var go = new GameObject();
go.AddComponent <AudioSource>();
AbstractLevel al = null;
if (fragmentBased)
{
var level = go.AddComponent <FragmentShaderLevel>();
level.timelineRate = 0.4f;
al = level;
}
else
{
//go.AddComponent<AbstractLevel>();
}
foreach (var p in new string[] { blackPath, whitePath })
{
// set texture/sprite properties:
var importer = (TextureImporter)AssetImporter.GetAtPath(p);
importer.wrapMode = TextureWrapMode.Clamp;
importer.textureType = TextureImporterType.Sprite;
var texSettings = new TextureImporterSettings();
importer.ReadTextureSettings(texSettings);
texSettings.spriteAlignment = (int)SpriteAlignment.TopLeft;
texSettings.spriteMode = (int)SpriteImportMode.Single;
importer.SetTextureSettings(texSettings);
importer.mipmapEnabled = false;
importer.maxTextureSize = 2048;
importer.SaveAndReimport();
// create prefab
var prefabPath = System.IO.Path.ChangeExtension(p, "prefab").Replace("\\", "/");
var spriteGo = new GameObject();
var sr = spriteGo.AddComponent <SpriteRenderer>();
sr.sortingLayerName = "Playfield";
sr.sortingOrder = 1;
sr.sprite = AssetDatabase.LoadAssetAtPath <Sprite>(p);
PrefabUtility.SaveAsPrefabAsset(spriteGo, prefabPath);
GameObject.DestroyImmediate(spriteGo);
var prefabLoaded = AssetDatabase.LoadAssetAtPath <GameObject>(prefabPath);
if (p.Contains("Black"))
{
al.prefabBlack = prefabLoaded;
al.colorBlack = GetDominantColor(p);
}
else
{
al.prefabWhite = prefabLoaded;
al.colorWhite = GetDominantColor(p);
}
}
al.backgroundMaterial = newMaterial;
// setup level prefab:
var assetPath = shaderPath.Replace("\\", "/").Replace(".shader", ".prefab");
PrefabUtility.SaveAsPrefabAsset(go, assetPath);
GameObject.DestroyImmediate(go);
}
