public override void Update(LevelDefinition levelDefinition)
{
Player player = Player.local;
if (!initialized || player == null || player.body == null)
{
return;
}
var rightHand = (player.body.handRight != null);
var leftHand = (player.body.handLeft != null);
if (rightHand && !leftHand)
{
HandleCast(player.body.handRight, null);
}
if (!rightHand && leftHand)
{
HandleCast(player.body.handLeft, null);
}
if (rightHand && leftHand)
{
HandleCast(player.body.handRight, player.body.handLeft);
}
}
public static bool ParseLevelJson(string levelName, out LevelDefinition levelDefinition)
{
string path = Path.Combine(Application.streamingAssetsPath, "LevelDefinitions/" + levelName);
if (File.Exists(path))
{
var jsonLevel = File.ReadAllText(path);
try
{
levelDefinition = JsonConvert.DeserializeObject <LevelDefinition>(jsonLevel);
}
catch (Exception e)
{
throw e;
}
return(true);
}
else
{
Debug.Log("Can't load " + levelName + " from path: " + path);
levelDefinition = null;
return(false);
}
}
private void ValidateLevel(LevelDefinition data)
{
data.name = "Room " + data.room.ToString();
int numReturns = 0;
for (int i = 0; i < data.items.Length; i++)
{
data.items[i].name = data.items[i].type.ToString();
if (data.items[i].type == ItemType.Portal)
{
data.items[i].name += " " + data.items[i].portalType;
}
if (data.items[i].type == ItemType.Tool)
{
data.items[i].name += " " + data.items[i].toolType;
}
data.items[i].name += " " + data.items[i].number;
if (data.items[i].type == ItemType.Portal && data.items[i].portalType == PortalType.Return)
{
numReturns++;
}
}
if (numReturns != 1)
{
Debug.Log("WARNING: Level " + data.room + " has " + numReturns + " return portals!");
}
}
private void DrawLevel(LevelDefinition levelDefinition)
{
var levelSerializedObject = new SerializedObject(levelDefinition);
EditorGUILayout.PropertyField(levelSerializedObject.FindProperty("PowerUps"), true);
EditorGUILayout.PropertyField(levelSerializedObject.FindProperty("Rounds"), true);
levelSerializedObject.ApplyModifiedProperties();
DrawHorizontalSlider();
while (levelDefinition.EnemiesList.Count < levelDefinition.Rounds)
{
levelDefinition.EnemiesList.Add(CreateInstance <EnemiesDefinition>());
}
levelDefinition.EnemiesList.Resize(levelDefinition.Rounds, CreateInstance <EnemiesDefinition>);
foreach (var enemiesDefinition in levelDefinition.EnemiesList)
{
var serializedObject = new SerializedObject(enemiesDefinition);
EditorGUILayout.PropertyField(serializedObject.FindProperty("EnemyName"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("Count"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("Delay"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("InstantiationInterval"), true);
serializedObject.ApplyModifiedProperties();
}
}
public GameLogicLayer(LevelDefinition levelDefinition)
{
_levelDefinition = levelDefinition;
// Parse your level content here
var x = levelDefinition.Content;
}
private void WriteEnemies(LevelDefinition definition)
{
WriteEnemyComments();
_writer.StartObject(ObjectType.Fast, "Enemies");
foreach (var enemyKeyValue in definition.Enemies)
{
var enemy = enemyKeyValue.Value;
var offset = _writer.GetCurrentOffset(ObjectType.Fast);
WriteBobOffset(enemy.Bob, enemyKeyValue);
_writer.WriteWord(enemy.FrameDelay);
_writer.WriteWord(enemy.Hp);
var pointString = enemy.Points.ToString("D8");
foreach (var s in Enumerable.Range(0, 4).Select(i =>
byte.Parse($"{pointString.Substring(i * 2, 2)}", NumberStyles.HexNumber)))
{
_writer.WriteByte(s);
}
var soundOffset = (ushort)_items.Get(ItemTypes.Sound, enemy.ExplosionSound, enemyKeyValue.Key).Offset;
_writer.WriteWord(soundOffset);
WriteBobOffset(enemy.PortalBob, enemyKeyValue);
_items.Add(ItemTypes.Enemy, enemyKeyValue.Key, offset);
}
_writer.EndObject();
}
/// <summary>
/// Builds more level, according to the given amount.
/// </summary>
/// <param name="amount">
/// The amount of chunks that must be added to the level.
/// </param>
/// <param name="levelDefinition">
/// The level's definition used to build more level
/// (i.e this is used to know which type of chunks should be added).
/// </param>
/// <exception cref="System.ArgumentException">If the given amount is not positive</exception>
private void BuildLevel(int amount, LevelDefinition levelDefinition)
{
if (amount <= 0)
{
Debug.LogError("The amount of chunks to be added to the level must be positive.");
throw new ArgumentException("The amount must be positive");
}
var total = _amountOfCreatedChunks + amount; // Precalculates how many chunks will exist
while (_amountOfCreatedChunks < total)
{
var selectedChunkPrefab = GetAChunkPrefab(levelDefinition);
var chunk = Instantiate(selectedChunkPrefab);
chunk.name = "Chunk" + _amountOfCreatedChunks;
// The chunk must start in the next starting position 'x' component
var chunkLength = chunk.ChunkLength;
var chunkX = _nextStartingPosition + chunkLength / 2;
chunk.transform.position = new Vector3(chunkX, _levelStartingPosition.y, _levelStartingPosition.z);
// Update internal variables
_nextStartingPosition += chunkLength;
_amountOfCreatedChunks++;
_createdChunks.Add(chunk);
}
RecalculateCreationMarginLength(); // Calculate the margin in 'x' at which the level should be expanded.
}
public void Process(LevelDefinition definition)
{
if (definition.Sfx != null)
{
Render(definition.Sfx);
}
}
public override bool ValidateOperation(GameObject botObject, LevelDefinition levelDef)
{
Vector2 direction = levelDef.getDirectionFromEnum();
Vector2 nextPos = direction + levelDef.botPos;
// If the next position is in any way outside the board then it's illegal
if (nextPos.x < 0 || nextPos.x >= levelDef.numRows ||
nextPos.y < 0 || nextPos.y >= levelDef.numColumns)
{
return(false);
}
Tile currentTile = levelDef.board [(int)levelDef.botPos.x, (int)levelDef.botPos.y];
Tile nextTile = levelDef.board [(int)nextPos.x, (int)nextPos.y];
// We won't jump if the destination is at the same height level
if (currentTile.height == nextTile.height ||
(currentTile.height < nextTile.height && nextTile.height - currentTile.height > 1) ||
(currentTile.height > nextTile.height && currentTile.height - nextTile.height > 1))
{
return(false);
}
return(true);
}
public void Process(LevelDefinition definition)
{
if (definition.EnemyFire == null)
{
return;
}
_definition = definition.EnemyFire;
WriteEnemyFireComments();
_writer.StartObject(ObjectType.Fast, "EnemyFireTypes");
foreach (var fireKeyValue in _definition.Types)
{
var fire = fireKeyValue.Value;
var fireName = fireKeyValue.Key;
var offset = _writer.GetCurrentOffset(ObjectType.Fast);
_writer.WriteWord((ushort)_items.Get(ItemTypes.Sound, fire.Sound, fireName).Offset);
_writer.WriteWord((ushort)fire.Movement);
_writer.WriteWord((ushort)fire.Period);
_writer.WriteWord((ushort)fire.Speed);
var bob = _items.Get(ItemTypes.Bob, fire.Bob, fireName);
_writer.WriteOffset(ObjectType.Chip, bob.Offset);
_items.Add(ItemTypes.EnemyFire, fireName, offset);
}
_writer.EndObject();
WriteSupportingCode();
}
public override void Update(LevelDefinition levelDefinition)
{
if (!Player.local)
{
return;
}
else
{
if (!Player.local.body)
{
leftIceWind = null;
rightIceWind = null;
return;
}
else
{
if (!Player.local.body.handLeft)
{
return;
}
else
{
GetIceWindSpell(Player.local.body.handLeft);
GetIceWindSpell(Player.local.body.handRight);
}
}
}
}
public static Level Load( LevelDefinition def )
{
Level l = new Level();
l.definition = def;
l.Begin();
return l;
}
private void ConvertTiles(LevelDefinition definition)
{
foreach (var tiledDefinition in definition.Tiles)
{
_tiledConverter.ConvertAll(tiledDefinition.Key, tiledDefinition.Value);
}
}
public void SaveToFile()
{
if (!VerifyLevel())
{
return;
}
var levelDefinition = new LevelDefinition();
levelDefinition.dimensions = tileMapSize;
levelDefinition.blockTypeSerializedGrid = new BlockType[tileMapSize.x * tileMapSize.y];
for (var x = 0; x < tileMapSize.x; ++x)
{
for (var y = 0; y < tileMapSize.y; ++y)
{
var linearMappedIndex = levelDefinition.CalculateLinearizedCoordinates(x, y);
levelDefinition.blockTypeSerializedGrid[linearMappedIndex] = blocks[linearMappedIndex].blockType;
}
}
var jsonRepresentation = JsonUtility.ToJson(levelDefinition);
var formatter = new BinaryFormatter();
var file = OpenMapFileForWriting();
formatter.Serialize(file, jsonRepresentation);
file.Close();
}
public LevelManager(GameInstance game, ChooseMap.Maps EnvMap)
{
this.game = game;
this.LevelNumber = -1;
LevelNumberStat = new Stat(Load.FontScore, Color.Red, "Level : ", 0);
LevelNumberStat.Position = new Vector2((TimGame.GAME_WIDTH - LevelNumberStat.Size.X) / 2, 25);
Title = new Item("Level X", Load.FontTitleLevel, Color.Blue);
Title.Position = new Vector2((TimGame.GAME_WIDTH - Title.Size.X) / 2,
(TimGame.GAME_HEIGHT - Title.Size.Y) / 2);
map = new Map(Load.BackgroundSun, Load.MapTextureNature, EnvMap);
LevelDefinition Level1 = new LevelDefinition(map, Load.BackgroundSun, Load.MapTextureNature,
10, 0.3f, Color.Black, true, false);
LevelDefinition Level2 = new LevelDefinition(map, Load.BackgroundGreen, Load.MapTextureDesert,
15, 0.2f, Color.Black, true, false);
LevelDefinition Level3 = new LevelDefinition(map, Load.BackgroundDark, Load.MapTextureGraveyard,
20, 0.15f, Color.White, true, false);
LevelDefinition Level4 = new LevelDefinition(map, Load.BackgroundWinter, Load.MapTextureWinter,
25, 0.15f, Color.Black, true, true);
LevelDefinition Level5 = new LevelDefinition(map, Load.BackgroundSun, Load.MapTextureNature,
int.MaxValue, 0.1f, Color.Black, true, true);
Levels = new List <LevelDefinition> {
Level1, Level2, Level3, Level4, Level5
};
SetLevel(0);
}
public override void OnLevelLoaded(LevelDefinition levelDefinition)
{
foreach (var customTriggerData in triggerData)
{
string triggerType = customTriggerData.triggerType.ToLower();
Debug.Log("Attempting to create custom trigger of type " + triggerType);
if (!triggerTypeMap.ContainsKey(triggerType))
{
Debug.LogError("Invalid custom trigger type [" + triggerType + "]");
continue;
}
List <LevelDefinition.CustomReference> customReferences = levelDefinition.customReferences.FindAll(r => r.name == customTriggerData.customReferenceId);
if (customReferences.Count != 1)
{
Debug.LogError("Expected only 1 custom reference with name " + customTriggerData.customReferenceId);
continue;
}
LevelDefinition.CustomReference currentReference = customReferences[0];
CustomTrigger trigger = currentReference.transforms[0].gameObject.AddComponent(triggerTypeMap[triggerType]) as CustomTrigger;
Debug.Log("Added trigger of type " + triggerTypeMap[triggerType].Name + " to CustomReference " + customTriggerData.customReferenceId);
trigger.Initialize(customTriggerData, currentReference.transforms);
}
base.OnLevelLoaded(levelDefinition);
}
public static Level Load(LevelDefinition def)
{
Level l = new Level();
l.definition = def;
l.Begin();
return(l);
}
public override void Update(LevelDefinition levelDefinition)
{
if (!initialized)
{
return;
}
// Add code here.
}
private void ConvertBobToDisk(string name, BobDefinition bob, LevelDefinition definition, Bitmap bobPalette)
{
var offset = _writer.GetCurrentOffset(ObjectType.Chip);
_bobConverter.ConvertBob(name, bob, definition.BobPlaneCount, bobPalette.Palette,
_definition.BobPaletteFlip0AndLast ? BobMode.ColorFlip : BobMode.NoColorFlip, Destination.Disk);
_items.Add(ItemTypes.Bob, name, offset);
}
/// <summary>
/// Creates the screen
/// </summary>
/// <param name="game">Snails Pace instance</param>
/// <param name="levelsSetting">The levels for the game, [n][0] = display name, [n][1] = file</param>
public LevelSelectScreen(SnailsPace game, String[][] levelsSetting )
: base(game)
{
levels = new LevelDefinition[levelsSetting.Length];
for (int index = 0; index < levelsSetting.Length; index++)
{
levels[index] = new LevelDefinition(levelsSetting[index][0], levelsSetting[index][1]);
}
}
/// <summary>Creates an instance of IWorld</summary>
/// <param name="definition">World definition</param>
/// <returns>The created IWorld instance</returns>
public override IWorld Create(LevelDefinition definition)
{
return(new UnityWorld(
definition,
this.Resources,
this.ControllerManager,
this.ControllerFactories,
this.EntityFactory));
}
/// <summary>Initializes a new instance of the TestEntity class</summary>
public TestWorld(
LevelDefinition definition,
IResourceLibrary resources,
IControllerManager controllerManager,
IControllerFactory[] controllerFactories,
IEntityFactory entityFactory)
: base(definition, resources, controllerManager, controllerFactories, entityFactory)
{
}
/// <summary>Initializes a new instance of the UnityWorld class</summary>
public UnityWorld(
LevelDefinition definition,
IResourceLibrary resources,
IControllerManager controllerManager,
IControllerFactory[] controllerFactories,
IEntityFactory entityFactory)
: base(definition, resources, controllerManager, controllerFactories, entityFactory)
{
SafeECall.Invoke(() => WorldBehaviour.Instance.World = this);
}
public void StartLevel(LevelDefinition level)
{
levelEndPopUp.SetActive(false); // reset
instruction1Solved = false;
instruction2Solved = false;
correctAnswers = 0; // reset
incorrectAttempts = 0; // reset
playerWonLevel = false; // reset
levelFinished = false; // reset
}
public override void RunOperation(GameObject botObject, LevelDefinition levelDef)
{
Vector2 currentPos = levelDef.botPos;
Tile currentTile = levelDef.board [(int)currentPos.x, (int)currentPos.y];
currentTile.lightOn = true;
Renderer r = currentTile.associatedGO.GetComponent <Renderer> ();
r.sharedMaterial = lightOnMat;
}
public override void OnLevelLoaded(LevelDefinition levelDefinition)
{
helperModule.instance = this;
base.OnLevelLoaded(levelDefinition);
Debug.LogError("Helper Reborn Module:\nhelperModule.activationWord Word: " + activationWord + "\nhelperModule.confidenceNeeded Requirement: " + confidenceNeeded);
GameObject g = new GameObject();
HelperMain m = g.AddComponent <HelperMain>();
GameObject.DontDestroyOnLoad(g);
}
public void RoundtripLevelDefinition()
{
var entities = new EntityDefinition[]
{
new EntityDefinition
{
Id = Guid.NewGuid().ToString(),
AvatarId = Guid.NewGuid().ToString(),
Mass = 1f,
},
new EntityDefinition
{
Id = Guid.NewGuid().ToString(),
AvatarId = Guid.NewGuid().ToString(),
Mass = 1f,
},
};
var expected = new LevelDefinition
{
Id = Guid.NewGuid().ToString(),
Title = Guid.NewGuid().ToString(),
Description = Guid.NewGuid().ToString(),
Entities =
{
new LevelDefinition.EntityCollection.Entry
{
EntityId = entities[0].Id,
Position = Vector3D.Zero,
Direction = Vector3D.Zero,
Velocity = Vector3D.Zero,
},
new LevelDefinition.EntityCollection.Entry
{
EntityId = entities[1].Id,
Position = Vector3D.Identity,
Direction = Vector3D.Identity,
Velocity = Vector3D.Zero,
},
},
};
var xml = expected.ToString();
Assert.IsFalse(string.IsNullOrEmpty(xml));
var actual = LevelDefinition.FromString(xml);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.Title, actual.Title);
Assert.AreEqual(expected.Description, actual.Description);
Assert.AreEqual(expected.Entities.Count, actual.Entities.Count);
}
/// <summary>
/// Returns a random chunk prefab according to the given level definition.
/// </summary>
/// <param name="levelDefinition">The level definition used to know which chunk prefabs can be returned.</param>
/// <returns></returns>
private Chunk GetAChunkPrefab(LevelDefinition levelDefinition)
{
var chunkLelve = GetRandomWithProbability(levelDefinition.Probabilities);
var chunks = _chunksByDifficulty[chunkLelve];
Random.state = _randomState; // Set the state.
var randomIndex = Random.Range(0, chunks.Count);
_randomState = Random.state; // Save the state
return(chunks[randomIndex]);
}
LevelDefinition GenerateDefinitionFromLevelResource(string levelName)
{
FileIO fileIO = new FileIO(levelName, "txt");
string fileText = fileIO.GetFileText();
if (fileText == null)
{
return(null);
}
var levelInfoDict = new Dictionary <string, Dictionary <string, string> >();
foreach (var line in fileText.Split('\n'))
{
if (line.StartsWith("//")) // line comment
{
continue;
}
if (!(string.IsNullOrEmpty(line) || line.Trim().Length == 0)) // if not an empty line
{
string dataIdentifier = line.Split(':')[0].ToLower();
string dataValue = line.Split(':')[1].Trim();
string dataCategory = dataIdentifier.Split('/')[0];
string dataProperty = dataIdentifier.Split('/')[1];
if (!levelInfoDict.ContainsKey(dataCategory))
{
// add key to external dict
levelInfoDict.Add(dataCategory, new Dictionary <string, string>());
}
levelInfoDict[dataCategory].Add(dataProperty, dataValue);
}
}
LevelDefinition levelDefinition = new LevelDefinition(int.Parse(levelInfoDict["levelmanager"]["mapheight"]));
// todo: do this procedurally based on what's available
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.DIRT, ref levelInfoDict));
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.DIRT2, ref levelInfoDict));
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.GOLD_VEIN, ref levelInfoDict));
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.STONE, ref levelInfoDict));
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.STONE2, ref levelInfoDict));
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.ALIEN_TECH, ref levelInfoDict));
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.ENERGY_WELL, ref levelInfoDict));
levelDefinition.AddTileGenerationInfo(LevelDefinitionParser.GenerateInfoForOneType(Tile.TileType.RIFT, ref levelInfoDict));
// add wave definitions
levelDefinition.AddWaveDefinitions(LevelDefinitionParser.GenerateWaveInfoForType(Tile.TileType.RIFT, ref levelInfoDict));
return(levelDefinition);
}
public void Initialize(string levelName)
{
LevelDefinition levelDefinition = GenerateDefinitionFromLevelResource(levelName);
if (levelDefinition == null)
{
levelDefinition = GenerateDefinitionFromLevelResource("Level 1");
Debug.LogWarning("No resource found. defaulting to level 1");
}
LevelGenerator.Instance.Initialize(levelDefinition, GetTechSettingsDefinition(levelName));
}
private void StartLevel(int levelIndex)
{
currentLevel = levels[levelIndex];
StartCoroutine(SpawnShip(false));
StartCoroutine(SpawnEnemies());
if (currentLevel.hasPowerUps)
{
StartCoroutine(SpawnPowerUp());
}
}
private void Start()
{
IntroSequence.SetActive(true);
director.SetActive(true);
gameStartButton.onClick.AddListener(DeactivateIntroTimeline);
correctAnswers = 0;
incorrectAttempts = 0;
levelFinished = false;
levelEndPopUp.SetActive(false);
currentLevel = levels[0];
StartLevel(currentLevel);
}
