/// <summary>
/// Updates or creates a resource based on the resource identifier. The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database. If the resource "id" is provided in the JSON body, it will be ignored as well.
/// </summary>
/// <param name="id">A resource identifier specifying the resource to be updated.</param>
/// <param name="IfMatch">The ETag header value used to prevent the PUT from updating a resource modified by another consumer.</param>
/// <param name="body">The JSON representation of the "levelDescriptor" resource to be updated.</param>
/// <returns>A RestSharp <see cref="IRestResponse"/> instance containing the API response details.</returns>
public IRestResponse PutLevelDescriptor(string id, string IfMatch, LevelDescriptor body)
{
var request = new RestRequest("/levelDescriptors/{id}", Method.PUT);
request.RequestFormat = DataFormat.Json;
request.AddUrlSegment("id", id);
// verify required params are set
if (id == null || body == null)
{
throw new ArgumentException("API method call is missing required parameters");
}
request.AddHeader("If-Match", IfMatch);
request.AddBody(body);
request.Parameters.First(param => param.Type == ParameterType.RequestBody).Name = "application/json";
var response = client.Execute(request);
var location = response.Headers.FirstOrDefault(x => x.Name == "Location");
if (location != null && !string.IsNullOrWhiteSpace(location.Value.ToString()))
{
body.id = location.Value.ToString().Split('/').Last();
}
return(response);
}
public virtual void ExecuteSelectLevel(LevelDescriptor argument)
{
this.SelectLevel.OnNext(new SelectLevelCommand()
{
Argument = argument
});
}
public override void SelectLevel(LevelSelectScreenViewModel viewModel, LevelDescriptor arg) {
base.SelectLevel(viewModel, arg);
// This can be extracted into a service to load levels from other places
// without duplicated code. Also external service could handle rules,
// under which certain level can/cannot be loaded
if (arg.IsLocked) return; //Level is locked, do not switch scenes
Publish(new UnloadSceneCommand()
{
SceneName = "MainMenuScene" // Unload main menu scene
});
Publish(new LoadSceneCommand()
{
//SceneName = arg.LevelScene // Load level scene
SceneName = "MainGameScene" // Load level scene
});
Publish(new NotifyCommand()
{
Message = "Playing "+arg.Title
});
}
public LevelDescriptor createNewLevelDescriptor(string name)
{
LevelDescriptor lDesc = new LevelDescriptor(name);
lDesc.ensureFileExists();
return(lDesc);
}
public virtual void ExecuteSelectLevel(LevelDescriptor arg)
{
LevelSelectScreen.SelectLevel.OnNext(new SelectLevelCommand()
{
Sender = LevelSelectScreen, Argument = arg
});
}
public void LoadTexts(LevelDescriptor levelConfiguration)
{
List <string> mandTexts = new List <string>();
if (levelConfiguration.MandatoryBloxes.Count > 0)
{
mandTexts.Add("-" + string.Format(ObjectivePanelMessages.MANDATORY_BLOXES,
string.Join(", ", levelConfiguration.MandatoryBloxes.Select(m => string.Format(ObjectivePanelMessages.EXPECTED_BLOX_TEMPLATE, m.MinimumQuantity, m.Blox.gameObject.name.Replace("Blox", ""))))));
}
mandTexts.Add("-" + ObjectivePanelMessages.MANDATORY_STEPS);
if (levelConfiguration.SpecialActionBlox != null)
{
mandTexts.Add("-" + string.Format(ObjectivePanelMessages.MANDATORY__SPECIAL_STEPS, levelConfiguration.SpecialActionBlox.ACTION_DESCRIPTION));
}
//ADICIONAR ENTRADA PARA SPECIAL BLOX NO DESCRIPTOR E ADICIONA-LO AOS OBRIGATORIOS
MandatoryObjectivesText.text = string.Join("\n", mandTexts);
List <string> optionalTexts = new List <string>();
if (levelConfiguration.OptionalExpectedBloxes.Count > 0)
{
optionalTexts.Add("-" + string.Format(ObjectivePanelMessages.OPTIONAL_BLOXES,
string.Join(", ", levelConfiguration.OptionalExpectedBloxes.Select(m => string.Format(ObjectivePanelMessages.EXPECTED_BLOX_TEMPLATE, m.MinimumQuantity, m.Blox.gameObject.name.Replace("Blox", ""))))));
}
optionalTexts.Add("-" + string.Format(ObjectivePanelMessages.OPTIONAL_ATTEMPTS, levelConfiguration.MaxAttempts));
optionalTexts.Add("-" + string.Format(ObjectivePanelMessages.OPTIONAL_LINES, levelConfiguration.MaxCodeLinesExpected));
optionalTexts.Add("-" + string.Format(ObjectivePanelMessages.TIME, levelConfiguration.MaxTimeInMinutes));
OptionalObjectivesText.text = string.Join("\n", optionalTexts);
}
public LevelDescriptor GetLevelDescriptor(int id)
{
LevelDescriptor d = null;
if (id >= 2000 && id <= 3000)
{
d = new LevelDescriptor();
d.Infos.Id = id;
d.Infos.Difficulty = "";
if (id == 2001)
d.Infos.Mission = GetWorldStringId(2);
else if (id == 2002)
d.Infos.Mission = GetWorldStringId(3);
else if (id == 2003)
d.Infos.Mission = GetWorldStringId(1);
else if (id == 2004)
d.Infos.Mission = GetWorldStringId(2);
}
else
{
d = Descriptors[id];
}
return d;
}
public void CreateBoard(LevelDescriptor level)
{
currentLevel = level;
DestroyBoard();
width = level.width;
height = level.height;
// scale and offset to centre
float scale = minScale; // easier just to use the min scale - also changing piece size might feel bad for the player's muscle memory?
transform.localScale = Vector3.one * scale;
transform.position = new Vector3(-(width - 1) / 2.0f, -(height - 1) / 2.0f, 0) * scale + screenOffset;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (level.GetTile(x, y))
{
boardGOs[x, y] = tilesPool.Get();
tiles[x, y] = boardGOs[x, y].GetComponent <BoardTile>();
tiles[x, y].Reset(x, y);
boardGOs[x, y].SetActive(true);
// assume board tiles are 1x1 world units in size
boardGOs[x, y].transform.localPosition = new Vector3(x, y, 0);
}
}
}
FillBoard();
}
public void SetInitialStatus(LevelDescriptor descriptor, int connectedDisplaysCount, int displaysCount)
{
float scale = 1f;
float difficultScale = scale / 2;
var padding = new Vector2(8, 2);
m_levelIndex.SetParams('#' + (descriptor.Index + 1).ToString(), scale, padding);
m_levelSizeLabel.SetParams(descriptor.Width + " x " + descriptor.Height, scale, padding);
m_levelDifficult.ScaleX = difficultScale;
m_levelDifficult.ScaleY = difficultScale;
m_levelDifficult.SetColor(Game.Content.Colors.DifficultColors[descriptor.Difficult]);
m_conectedLabel.SetParams(connectedDisplaysCount.ToString() + " / " + displaysCount.ToString(), scale, padding);
m_levelIndex.X = m_levelIndex.Width / 2 + m_spacing;
m_levelIndex.Y = m_levelIndex.Height / 2 + m_spacing;
m_levelSizeLabel.X = m_levelIndex.X + m_levelIndex.Width / 2 + m_levelSizeLabel.Width / 2 + m_spacing;
m_levelSizeLabel.Y = m_levelIndex.Y;
m_levelDifficult.X = m_levelSizeLabel.X + m_levelSizeLabel.Width / 2 + m_levelDifficult.Width * m_levelDifficult.ScaleX / 2 + m_spacing;
m_levelDifficult.Y = m_levelIndex.Y;
m_conectedLabel.X = m_conectedLabel.Width / 2 + m_spacing;
m_conectedLabel.Y = m_levelIndex.Y + m_levelIndex.Height / 2 + m_conectedLabel.Height / 2 + m_spacing;
}
/// <summary>
/// Sets the initial position and the bot settings of the cubot
/// </summary>
/// <param name="initialPlotTile"></param>
/// <param name="initialOrientation"></param>
public void SetUp(LevelDescriptor configuration, List <PlotTile> tilesInScene)
{
this.tilesInScene = tilesInScene;
CurrentOrientation = configuration.CharacterInitialOrientation;
Vector3 cubotExtents = this.GetComponent <Renderer>().bounds.extents;
Vector3Int cubotPlotInitialPosition = configuration.CharacterStartPointInPlot;
PlotTile initialPlotTile = tilesInScene.Where(t => t.PlotPosition == cubotPlotInitialPosition).First();
float rotY = (int)CurrentOrientation;
Vector3 initialPlotTileExtents = initialPlotTile.GetComponent <Renderer>().bounds.extents;
//Cubot must be over an initial plot tile, so we are going to position it
Vector3 initialPosition = initialPlotTile.transform.position;
initialPosition.y += cubotExtents.y + initialPlotTileExtents.y;
Vector3 cubotInitialRotation = new Vector3(0, rotY, 0);
this.transform.position = initialPosition;
this.transform.rotation = Quaternion.Euler(cubotInitialRotation);
Speed = configuration.CharacterSpeed;
CurrentTile = initialPlotTile;
CurrentTile.Step();
}
public IActionResult AssessmentQuestionLevelDescriptor(LevelDescriptor levelDescriptor, int frameworkId, int level, int assessmentQuestionId = 0, int frameworkCompetencyId = 0)
{
var sessionAssessmentQuestion = multiPageFormService.GetMultiPageFormData <SessionAssessmentQuestion>(
MultiPageFormDataFeature.EditAssessmentQuestion,
TempData
);
if (!ModelState.IsValid)
{
ModelState.Remove(nameof(LevelDescriptor.LevelLabel));
ModelState.AddModelError(nameof(LevelDescriptor.LevelLabel), $"Please enter a valid option {level} label (between 3 and 255 characters)");
if (sessionAssessmentQuestion == null)
{
return(StatusCode(404));
}
var model = new AssessmentQuestionLevelDescriptorViewModel()
{
FrameworkId = frameworkId,
FrameworkCompetencyId = frameworkCompetencyId,
Name = sessionAssessmentQuestion.AssessmentQuestionDetail.Question,
AssessmentQuestionDetail = sessionAssessmentQuestion.AssessmentQuestionDetail,
LevelDescriptor = levelDescriptor,
};
return(View("Developer/AssessmentQuestionLevelDescriptor", model));
}
if (sessionAssessmentQuestion == null)
{
return(StatusCode(404));
}
var existingDescriptor = sessionAssessmentQuestion.LevelDescriptors.Find(x => x.LevelValue == level);
if (existingDescriptor != null)
{
sessionAssessmentQuestion.LevelDescriptors.Remove(existingDescriptor);
}
sessionAssessmentQuestion.LevelDescriptors.Add(levelDescriptor);
multiPageFormService.SetMultiPageFormData(
sessionAssessmentQuestion,
MultiPageFormDataFeature.EditAssessmentQuestion,
TempData
);
var assessmentQuestionDetail = sessionAssessmentQuestion.AssessmentQuestionDetail;
if (level >= assessmentQuestionDetail.MaxValue)
{
return(RedirectToAction(
"EditAssessmentQuestionOptions",
"Frameworks",
new { frameworkId, assessmentQuestionId, frameworkCompetencyId }
));
}
var nextLevel = level + 1;
return(RedirectToAction(
"AssessmentQuestionLevelDescriptor",
"Frameworks",
new { frameworkId, level = nextLevel, assessmentQuestionId, frameworkCompetencyId }
));
}
public void ClearMode()
{
// this is called by level selection to ensure we're in the right state
// by default we assume we're in edit mode to allow for testing levels directly in the editor
CurrentMode = Mode.None;
CurrentLevel = null;
ClearPlayState();
}
public void StartLevel(LevelDescriptor level)
{
state = State.Idle;
currentLevel = level;
scoreLerp = 0;
scoreValueText.text = scoreLerp.ToString("D6");
playerState.OnContinueGame();
board.CreateBoard(level);
}
//Reset vars and run level
private void StartLevel()
{
currentLevel = GameController.Instance.CurrentLevel;
currentInterval = 0f;
CurrentHealth = GameController.Instance.CurrentGameSettings.defaultHealth;
killCounter = 0;
levelTime = 0f;
active = true;
}
public void setFromLevel(LevelDescriptor descriptor)
{
Invoke(new NoArgFunction(() =>
{
prevLightingBox.Checked = descriptor.Level.PreviewLighting;
prevShadowBox.Checked = descriptor.Level.PreviewShadowing;
enableLightingBox.Checked = descriptor.Level.LightingEnabled;
enableShadowBox.Checked = descriptor.Level.ShadowingEnabled;
}));
}
public override void AvailableLevelsOnRemove(LevelDescriptor levelDescriptor)
{
/* Simply remove visual representation of LevelDescriptor, if it ever exited */
var item = LevelListContainer.FindChild(levelDescriptor.LevelScene);
if (item != null)
{
Destroy(item.gameObject);
}
}
public LevelDocument(LevelDescriptor levelDescriptor, DocumentView parent)
: base(levelDescriptor.FilePath, parent)
{
Text = levelDescriptor.Name;
Descriptor = levelDescriptor;
initControls();
addControls();
whiskey.AllowDrop = true;
//whiskey.BecameDirty += (s, a) =>
//{
// Dirty = true;
//};
whiskey.MouseUp += (s, a) =>
{
if (SelectionManager.Instance.SelectedInstance != null)
{
requestPropertyChange(SelectionManager.Instance.SelectedInstance);
}
};
SelectionManager.Instance.SelectedInstanceUpdated += (s, a) =>
{
if (SelectionManager.Instance.SelectedInstance != null)
{
// requestPropertyChange(SelectionManager.Instance.SelectedInstance); //TODO fix how slow this is
}
else
{
if (ParentController.Tabs.SelectedTab == this)
{
requestPropertyChange(Descriptor);
}
}
};
dragEnterHandler = new DragEventHandler(dragEnter);
dragDropHandler = new DragEventHandler(dragDrop);
base.addAction(new PlayLevelAction(Descriptor));
base.addAction <ToolStripDropDownButton>(new ViewInstanceDetailsAction(Descriptor.Level));
base.addAction <ToolStripDropDownButton>(new ViewLevelLayersAction(Descriptor));
base.addAction(new CopyInstanceAction());
base.addAction(new PasteInstanceAction(Descriptor));
// base.addAction<ToolStripDropDownButton>(new ToggleLightingAction(Descriptor));
base.addAction <ToolStripDropDownButton>(new ToggleLightingAction(Descriptor));
base.addAction(new IncreaseGridSnapAction());
base.addAction(new DecreaseGridSnapAction());
base.addAction(new ToggleHudAction(Descriptor));
}
public virtual void setGameData(GameData data)
{
if (data == null)
{
return;
}
//TODO notify someone that everything is gone
fileDescs.Clear();
fileDescMap.Clear();
FileDescriptor[] files = new FileDescriptor[data.Files.Count];
ScriptManager.Instance.clear();
data.Files.CopyTo(files);
// = objs.ToList();
////add core types
//foreach (CoreTypeDescriptor c in WhiskeyEditor.compile_types.CoreTypes.typeFileNameMap.Values)
//{
// addFileDescriptor(c);
//}
////add core scripts
//foreach (CoreScriptDescriptor c in WhiskeyEditor.compile_types.CoreTypes.scriptFileNameMap.Values)
//{
// addFileDescriptor(c);
//}
List <LevelDescriptor> levels = new List <LevelDescriptor>();
foreach (FileDescriptor f in files)
{
//if (f is CoreScriptDescriptor || f is CoreTypeDescriptor)
// continue; //we don't care about core descriptors
addFileDescriptor(f);
if (f is LevelDescriptor)
{
LevelDescriptor l = (LevelDescriptor)f;
l.Level.updateAll();
levels.Add(l);
InstanceManager.Instance.addLevel(l.Level);
}
else if (f is ScriptDescriptor)
{
ScriptDescriptor s = (ScriptDescriptor)f;
ScriptManager.Instance.addScript(s);
}
}
levels.ForEach((l) =>
{
l.Level.updateAll();
l.Level.syncAllTypesToInstances();
});
}
protected override bool Click(Circle circle)
{
if (!base.Click(circle))
return false;
foreach (var b in PushButtons)
if (b.Value.DoClick(circle))
{
ClickedLevel = b.Key;
return true;
}
return false;
}
public void LoadLevel(Mode mode, LevelDescriptor level = null)
{
level = level ?? CurrentLevel;
if (CurrentMode == Mode.Edit)
{
SaveFuseSettings();
}
CurrentMode = mode;
CurrentLevel = level;
ClearPlayState();
SceneManager.LoadScene(level.sceneName);
}
public override void AvailableLevelsOnAdd(LevelDescriptor levelDescriptor)
{
/*
* We use naming convention: we name LevelListItems using LevelDescriptor.LevelScene property,
* as it is unique for every level.
*
* Before actually creating a new LevelListItem, we ensure that it is not already in the list
*/
var item = LevelListContainer.FindChild(levelDescriptor.LevelScene);
if (item != null)
{
return;
}
/* Instantiate new LevelListItem */
var go = Instantiate(LevelListItemPrefab) as GameObject;
item = go.transform;
/* Parent created LevelListItem to the container */
item.SetParent(LevelListContainer);
/*
* Each LevelListItem has similar hierarchy. We can use it and setup different objects and their
* values, based on the LevelDescriptor
*/
item.FindChild("LevelTitle").GetComponent <Text>().text = levelDescriptor.Title;
item.FindChild("LevelDescription").GetComponent <Text>().text = levelDescriptor.Description;
/* Setup the name based on LevelDescriptor.LevelScene */
item.gameObject.name = levelDescriptor.LevelScene;
/* Make button interactable, if level is unlocked */
item.GetComponent <Button>().interactable = !levelDescriptor.IsLocked;
/* Make button scale 1,1,1 in case unity overrides it during instantiation */
item.GetComponent <Button>().transform.localScale = Vector3.one;
/*
* MOST IMPORTANT: attach unique handler to this button,
* which executes command with a specific LevelDescriptor
*/
this.BindButtonToHandler(item.GetComponent <Button>(), () =>
{
ExecuteSelectLevel(levelDescriptor);
});
}
private void Refresh()
{
LevelDescriptor level = SimulationState.Instance.CurrentLevel;
SimulationState.PlayState state = SimulationState.Instance.CurrentPlayState;
if (level == null)
{
return;
}
textBombsDestroyed.text = state.destroyedBombs.ToString() + " / " + level.bombsInScene.ToString();
textFusesUsed.text = state.fusedBombs.ToString() + " / " + level.bombsFuseable.ToString();
objectiveBronze.Completed = (state.destroyedBombs >= level.bombsForBronze);
objectiveSilver.Completed = (state.destroyedBombs >= level.bombsForSilver);
objectiveGold.Completed = (state.destroyedBombs >= level.bombsForGold);
}
async Task LoadFieldDataAndShowField(LevelDescriptor descriptor, bool isGenerateNew)
{
m_field.BeginUpdateFieldData();
await Task.WhenAll(
Task.Delay(300),
Task.Run(() =>
{
if (isGenerateNew)
{
m_profile.DeleteFieldData(descriptor);
}
m_field.UpdateFieldData(m_profile.GetFieldData(descriptor), descriptor);
}));
m_field.EndUpdateFieldData();
m_screenManager.ScreenFront(m_field, m_loadingScreen);
}
public void LoadSquareTiles(LevelDescriptor levelConfiguration)
{
uint width = levelConfiguration.PlotWidth;
uint height = levelConfiguration.PlotLength;
List <ObjectiveStep> mandatorySteps = levelConfiguration.MandatorySteps;
BoundingBox2D tileBBox = GameObjectHelper.getBoundingBoxInWorld(TemplateTile.gameObject);
float sqWidth = GameObjectHelper.getWidthFromBBox(tileBBox);
float sqHeight = GameObjectHelper.getWidthFromBBox(tileBBox);
float sqDistance = sqWidth / 10; // distance between tiles
for (int plotY = 0; plotY < height; plotY++) //iterates through lines (y)
{
for (int plotX = 0; plotX < width; plotX++) //iterates through columns (x)
{
// Checks if this is a mandatory step, and obtains info
ObjectiveStep step = levelConfiguration.MandatorySteps.Where(s => s.CoordinateInPlot.x == plotX && s.CoordinateInPlot.y == plotY).FirstOrDefault();
// Creates the tile
SquareTile tile = (plotX + plotY) == 0 ? TemplateTile : TemplateTile.CloneThisTile();
//tile.transform.parent = TemplateTile.gameObject.transform.parent;
//tile.transform.position = TemplateTile.transform.position;
// Sets the tile colour
tile.SetColour(step == null ? SquareTile.STExpectedState.NOT_TO_STEP :
(step.SpecialAction ? SquareTile.STExpectedState.TO_EXECUTE_SPECIAL_ACTION : SquareTile.STExpectedState.TO_STEP));
// Sets the coordinates text display
tile.SetCoordinateText(plotX, plotY);
// Creates a new position
Vector3 newTilePos = tile.transform.position;
newTilePos.x += plotX * (sqWidth + sqDistance);
newTilePos.y += plotY * (sqHeight + sqDistance);
// Sets the new position
tile.transform.position = newTilePos;
squareTiles.Add(tile);
}
}
}
public void Start()
{
LevelDescriptor level = SimulationState.Instance.CurrentLevel;
SimulationState.Mode mode = SimulationState.Instance.CurrentMode;
if (level == null)
{
return;
}
buttonReset.interactable = (mode == SimulationState.Mode.Edit);
objectiveBronze.Text = level.bombsForBronze.ToString();
objectiveSilver.Text = level.bombsForSilver.ToString();
objectiveGold.Text = level.bombsForGold.ToString();
Refresh();
}
public LevelListViewItem(LevelDescriptor descriptor)
{
this.Height = Game.Content.GetSizeInDpi(40);
this.Descriptor = descriptor;
this.m_index = new TextSprite(Game.Content.Fonts.ButtonFont)
{
Text = (descriptor.Index + 1).ToString()
};
this.m_desc = new TextSprite(Game.Content.Fonts.ButtonFont)
{
Text = descriptor.Width + " x " + descriptor.Height
};
this.m_difficultBack = new AtlasSprite()
{
Frame = Game.Content.Textures.ButtonCircle
};
this.m_difficultBack.SetColor(Game.Content.Colors.DifficultColors[descriptor.Difficult]);
}
/*
* This is invoked every time we add new level descriptor to LevelSelectScreen.AvailableLevels collection
*/
public override void AvailableLevelsOnAdd(LevelDescriptor levelDescriptor)
{
/*
* We use naming convention: we name LevelListItems using LevelDescriptor.LevelScene property,
* as it is unique for every level.
*
* Before actually creating a new LevelListItem, we ensure that it is not already in the list
*/
var item = LevelListContainer.FindChild(levelDescriptor.LevelScene);
if (item != null) return;
/* Instantiate new LevelListItem */
var go = Instantiate(LevelListItemPrefab) as GameObject;
item = go.transform;
/* Parent created LevelListItem to the container */
item.SetParent(LevelListContainer);
/*
* Each LevelListItem has similar hierarchy. We can use it and setup different objects and their
* values, based on the LevelDescriptor
*/
item.FindChild("LevelTitle").GetComponent<Text>().text = levelDescriptor.Title;
item.FindChild("LevelDescription").GetComponent<Text>().text = levelDescriptor.Description;
/* Setup the name based on LevelDescriptor.LevelScene */
item.gameObject.name = levelDescriptor.LevelScene;
/* Make button interactable, if level is unlocked */
item.GetComponent<Button>().interactable = !levelDescriptor.IsLocked;
/* Make button scale 1,1,1 in case unity overrides it during instantiation */
item.GetComponent<Button>().transform.localScale = Vector3.one;
/*
* MOST IMPORTANT: attach unique handler to this button,
* which executes command with a specific LevelDescriptor
*/
this.BindButtonToHandler(item.GetComponent<Button>(), () =>
{
ExecuteSelectLevel(levelDescriptor);
});
}
private LevelDescriptor FindLevelDescriptorForCurrentScene()
{
LevelDescriptor level = null;
#if UNITY_EDITOR
Resources.LoadAll("Levels");
var levels = Resources.FindObjectsOfTypeAll <LevelDescriptor>();
foreach (var levelAsset in levels)
{
if (levelAsset.sceneName == SceneManager.GetActiveScene().name)
{
level = levelAsset;
}
if (levelAsset.sceneIndex < 0)
{
Debug.LogWarning("Level descriptor '" + levelAsset.name + "' references scene '" + levelAsset.sceneName + "' which is not included in build.");
}
}
#endif
return(level);
}
/// <summary>
/// Creates or updates resources based on the natural key values of the supplied resource. The POST operation can be used to create or update resources. In database terms, this is often referred to as an "upsert" operation (insert + update). Clients should NOT include the resource "id" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by "id"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.
/// </summary>
/// <param name="body">The JSON representation of the "levelDescriptor" resource to be created or updated.</param>
/// <returns>A RestSharp <see cref="IRestResponse"/> instance containing the API response details.</returns>
public IRestResponse PostLevelDescriptors(LevelDescriptor body)
{
var request = new RestRequest("/levelDescriptors", Method.POST);
request.RequestFormat = DataFormat.Json;
// verify required params are set
if (body == null)
{
throw new ArgumentException("API method call is missing required parameters");
}
request.AddBody(body);
var response = client.Execute(request);
var location = response.Headers.FirstOrDefault(x => x.Name == "Location");
if (location != null && !string.IsNullOrWhiteSpace(location.Value.ToString()))
{
body.id = location.Value.ToString().Split('/').Last();
}
return(response);
}
public override void SelectLevel(LevelSelectScreenViewModel viewModel, LevelDescriptor arg)
{
base.SelectLevel(viewModel, arg);
// This can be extracted into a service to load levels from other places
// without duplicated code. Also external service could handle rules,
// under which certain level can/cannot be loaded
if (arg.IsLocked)
{
return; //Level is locked, do not switch scenes
}
Publish(new UnloadSceneCommand()
{
SceneName = "MainMenuScene" // Unload main menu scene
});
Publish(new LoadSceneCommand()
{
SceneName = arg.LevelScene // Load level scene
});
}
// void fillNeighbors (){
// for (int i =0; i< dots.Length; i++) {
// int j = 0;
// if (dots[i].index -1 >=0 && dots[i-1].row == dots[i].row){
// dots[i].neighbors[j] = dots[i].index -1;
// j++;
// }
// if (dots[i].index +1 < dots.Length && dots[i+1].row == dots[i].row){
// dots[i].neighbors[j] = dots[i].index +1;
// j++;
// }
// if (dots[i].index - 12 >=0 && dots[i-12].row == dots[i].row-1){
// dots[i].neighbors[j] = dots[i].index -12;
// dots[i].down[0] = dots[i].index -12;
// dots[i].left[0] = dots[i].index -12;
// j++;
// }
// if (dots[i].index - 11 >=0 && dots[i-11].row == dots[i].row-1){
// dots[i].neighbors[j] = dots[i].index -11;
// dots[i].down[1] = dots[i].index -11;
// dots[i].right[0] = dots[i].index -11;
// j++;
// }
// if (dots[i].index + 12 < dots.Length && dots[i+12].row == dots[i].row+1){
// dots[i].neighbors[j] = dots[i].index +12;
// dots[i].right[1] = dots[i].index +12;
// dots[i].up[0] = dots[i].index +12;
// j++;
// }
// if (dots[i].index + 11 < dots.Length && dots[i+11].row == dots[i].row+1){
// dots[i].neighbors[j] = dots[i].index +11;
// dots[i].up[1] = dots[i].index +11;
// dots[i].left[1] = dots[i].index +11;
// j++;
// }
// }
// }
public void initializeLevel()
{
Debug.Log("Current level: " + LevelPicker.levelPick.currentLevel);
LevelDescriptor ld = LevelPicker.levelPick.levels[LevelPicker.levelPick.currentLevel];
for (int i = 0; i < ld.levelDesc.Length; i++)
{
if (blobs[i] != null)
{
blobs[i].selfdestroy();
}
if (ld.levelDesc[i] != -1)
{
createNewBlob(i, ld.levelDesc[i]);
}
}
partitions = ld.partitions;
if (!isTutorial)
{
partitionsText.text = "" + partitions;
levelText.text = "" + LevelPicker.levelPick.currentLevel;
}
}
/*
* This is invoked every time we remove level descriptor from LevelSelectScreen.AvailableLevels collection
*/
public override void AvailableLevelsOnRemove(LevelDescriptor levelDescriptor)
{
/* Simply remove visual representation of LevelDescriptor, if it ever exited */
var item = LevelListContainer.FindChild(levelDescriptor.LevelScene);
if(item!=null) Destroy(item.gameObject);
}
public LevelDescriptor GetEmptyDescriptor()
{
var l = new LevelDescriptor();
l.AddAsteroidBelt();
l.Infos.Id = GetHighestId() + 1;
l.Infos.Mission = "1-" + (GetHighestWorld1Level() + 1).ToString();
return l;
}
public static LevelDescriptor GetPerformanceTestDescriptor()
{
LevelDescriptor d = new LevelDescriptor();
CelestialBodyDescriptor c;
WaveDescriptor v;
d.Player.Lives = 1;
d.Player.Money = 100;
d.Infos.Background = "background14";
for (int i = 0; i < 6; i++)
{
c = new CelestialBodyDescriptor();
c.Name = i.ToString();
c.Path = new Vector3(150, 100, 0);
c.StartingPosition = (int) (i * 14f);
c.Size = Size.Small;
c.Speed = 120000;
c.Image = "stationSpatiale1";
c.PathPriority = 30 - i;
c.Invincible = true;
c.AddTurret(TurretType.Gravitational, 1, new Vector3(-6, 0, 0));
c.AddTurret(TurretType.Basic, 10, new Vector3(0, 6, 0));
c.AddTurret(TurretType.Basic, 10, new Vector3(0, -6, 0));
d.PlanetarySystem.Add(c);
}
d.Objective.CelestialBodyToProtect = d.PlanetarySystem[0].PathPriority;
for (int i = 0; i < 8; i++)
{
c = new CelestialBodyDescriptor();
c.Name = (i+8).ToString();
c.Path = new Vector3(300, 200, 0);
c.StartingPosition = (int)(i * 11f);
c.Size = Size.Small;
c.Speed = 120000;
c.Image = "stationSpatiale2";
c.PathPriority = 24 - i;
c.Invincible = true;
c.AddTurret(TurretType.Gravitational, 1, new Vector3(-6, 0, 0));
c.AddTurret(TurretType.MultipleLasers, 10, new Vector3(0, 6, 0));
c.AddTurret(TurretType.MultipleLasers, 10, new Vector3(0, -6, 0));
d.PlanetarySystem.Add(c);
}
for (int i = 0; i < 16; i++)
{
c = new CelestialBodyDescriptor();
c.Name = (i+16).ToString();
c.Path = new Vector3(450, 300, 0);
c.StartingPosition = (int)(i * 5f);
c.Size = Size.Small;
c.Speed = 120000;
c.Image = "stationSpatiale1";
c.PathPriority = 16 - i;
c.Invincible = true;
c.AddTurret(TurretType.Gravitational, 1, new Vector3(-6, 0, 0));
c.AddTurret(TurretType.Basic, 10, new Vector3(0, 6, 0));
c.AddTurret(TurretType.Basic, 10, new Vector3(0, -6, 0));
d.PlanetarySystem.Add(c);
}
c = new CelestialBodyDescriptor();
c.Name = "1111";
c.Path = new Vector3(700, -400, 0);
c.Speed = 320000;
c.Size = Size.Small;
c.Images.Add("Asteroid");
c.Images.Add("Plutoid");
c.Images.Add("Comet");
c.Images.Add("Centaur");
c.Images.Add("Trojan");
c.Images.Add("Meteoroid");
c.PathPriority = 0;
c.CanSelect = true;
d.PlanetarySystem.Add(c);
v = new WaveDescriptor();
v.Enemies = new List<EnemyType>() { EnemyType.Plutoid };
v.LivesLevel = 150;
d.Waves.Add(v);
v = new WaveDescriptor();
v.Enemies = new List<EnemyType>() { EnemyType.Comet };
v.LivesLevel = 150;
v.Quantity = 100;
d.Waves.Add(v);
v = new WaveDescriptor();
v.Enemies = new List<EnemyType>() { EnemyType.Meteoroid };
v.LivesLevel = 150;
v.Quantity = 100;
d.Waves.Add(v);
return d;
}
private void LoadMenuDescriptor()
{
Menu = LoadLevelDescriptor(DescriptorsDirectory + @"\menu.xml");
var newGame = Menu.PlanetarySystem[6];
newGame.Name = "save the world";
newGame.AddTurret(TurretType.Basic, 5, new Vector3(10, -14, 0), true, false);
newGame.Invincible = true;
var options = Menu.PlanetarySystem[1];
options.Name = "options";
options.AddTurret(TurretType.Basic, 2, new Vector3(-20, -5, 0), true, false);
options.AddTurret(TurretType.MultipleLasers, 4, new Vector3(12, 0, 0), true, false);
var editor = Menu.PlanetarySystem[2];
editor.Name = "editor";
editor.AddTurret(TurretType.Laser, 7, new Vector3(3, -7, 0), true, false);
editor.AddTurret(TurretType.Missile, 3, new Vector3(-8, 0, 0), true, false);
var quit = Menu.PlanetarySystem[3];
quit.Name = "quit";
var help = Menu.PlanetarySystem[4];
help.Name = "how to play";
help.AddTurret(TurretType.SlowMotion, 3, new Vector3(-10, -3, 0), true, false);
var credits = Menu.PlanetarySystem[5];
credits.Name = "credits";
credits.AddTurret(TurretType.SlowMotion, 1, new Vector3(-10, -3, 0), true, false);
DescriptorInfiniteWaves v = new DescriptorInfiniteWaves()
{
StartingDifficulty = 12,
DifficultyIncrement = 0,
MineralsPerWave = 0,
MinMaxEnemiesPerWave = new Vector2(10, 30),
Enemies = new List<EnemyType>() { EnemyType.Asteroid, EnemyType.Comet, EnemyType.Plutoid },
FirstOneStartNow = true,
Upfront = true,
NbWaves = 10
};
var asteroidBelt = LevelDescriptor.GetAsteroidBelt(Menu.PlanetarySystem);
asteroidBelt.Images = new List<string>() { "Asteroid", "Plutoid", "Comet", "Centaur", "Trojan", "Meteoroid" };
Menu.InfiniteWaves = v;
}
public Simulator(CommanderScene scene, LevelDescriptor descriptor)
{
Scene = scene;
Scene.Particles.Add(
new List<string>() {
@"projectileMissileDeplacement",
@"projectileBaseExplosion",
@"etoile",
@"etoileBleue",
@"planeteGazeuse",
@"etoilesScintillantes",
@"projectileMissileExplosion",
@"projectileLaserSimple",
@"projectileLaserMultiple",
@"selectionCorpsCeleste",
@"traineeMissile",
@"etincelleLaser",
@"toucherTerre",
@"anneauTerreMeurt",
@"anneauTerreMeurt2",
@"bouleTerreMeurt",
@"missileAlien",
@"implosionAlien",
@"explosionEnnemi",
@"mineral1",
@"mineral2",
@"mineral3",
@"mineralPointsVie",
@"mineralPris",
@"etincelleMissile",
@"etincelleLaserSimple",
@"etincelleSlowMotion",
@"etincelleSlowMotionTouche",
@"etoileFilante",
@"trouRose",
@"boosterTurret",
@"gunnerTurret",
@"nanobots",
@"nanobots2",
@"railgun",
@"railgunExplosion",
@"pulseEffect",
@"shieldEffect",
@"spaceshipTrail",
@"spaceshipTrail2",
@"darkSideEffect",
@"starExplosion",
@"mothershipMissile",
@"nextWave",
@"mothershipAbduction"
}, true);
Scene.Particles.SetMaxInstances(@"toucherTerre", 3);
TurretsFactory = new TurretsFactory(this);
PowerUpsFactory = new PowerUpsFactory(this);
EnemiesFactory = new EnemiesFactory(this);
MineralsFactory = new MineralsFactory(this);
BulletsFactory = new BulletsFactory(this);
TurretsFactory.Initialize();
PowerUpsFactory.Initialize();
EnemiesFactory.Initialize();
MineralsFactory.Initialize();
BulletsFactory.Initialize();
Level = new Level(this, descriptor);
TweakingController = new TweakingController(this);
CollisionsController = new CollisionsController(this);
BulletsController = new BulletsController(this);
EnemiesController = new EnemiesController(this);
SimPlayersController = new SimPlayersController(this);
TurretsController = new TurretsController(this);
PlanetarySystemController = new PlanetarySystemController(this);
SpaceshipsController = new SpaceshipsController(this);
MessagesController = new MessagesController(this);
GUIController = new GUIController(this);
PowerUpsController = new PowerUpsController(this);
LevelsController = new LevelsController(this);
EditorController = new EditorController(this);
EditorGUIController = new EditorGUIController(this);
PanelsController = new PanelsController(this);
AudioController = new AudioController(this);
WorldMode = false;
DemoMode = false;
CutsceneMode = false;
EditorMode = false;
CanSelectCelestialBodies = true;
EditorState = EditorState.Editing;
DebugMode = Preferences.Debug;
PausedGameChoice = PausedGameChoice.None;
NewGameChoice = NewGameChoice.None;
CollisionsController.ObjectHit += new PhysicalObjectPhysicalObjectHandler(EnemiesController.DoObjectHit);
CollisionsController.ObjectHit += new PhysicalObjectPhysicalObjectHandler(BulletsController.DoObjectHit);
CollisionsController.ObjectOutOfBounds += new PhysicalObjectHandler(BulletsController.DoObjectOutOfBounds);
SimPlayersController.BuyTurretAsked += new TurretSimPlayerHandler(TurretsController.DoBuyTurret);
EnemiesController.WaveEnded += new NoneHandler(LevelsController.DoWaveEnded);
EnemiesController.ObjectDestroyed += new PhysicalObjectHandler(SimPlayersController.DoObjectDestroyed);
CollisionsController.InTurretRange += new TurretPhysicalObjectHandler(TurretsController.DoInRangeTurret);
TurretsController.ObjectCreated += new PhysicalObjectHandler(BulletsController.DoObjectCreated);
BulletsController.ObjectDestroyed += new PhysicalObjectHandler(CollisionsController.DoObjectDestroyed);
EnemiesController.WaveStarted += new NoneHandler(GUIController.DoWaveStarted);
SimPlayersController.SellTurretAsked += new TurretSimPlayerHandler(TurretsController.DoSellTurret);
TurretsController.TurretSold += new TurretSimPlayerHandler(SimPlayersController.DoTurretSold);
TurretsController.TurretBought += new TurretSimPlayerHandler(SimPlayersController.DoTurretBought);
EnemiesController.EnemyReachedEndOfPath += new EnemyCelestialBodyHandler(PlanetarySystemController.DoEnemyReachedEnd);
TurretsController.TurretUpgraded += new TurretSimPlayerHandler(SimPlayersController.DoTurretUpgraded);
TurretsController.TurretUpgraded += new TurretSimPlayerHandler(GUIController.DoTurretUpgraded);
SimPlayersController.UpgradeTurretAsked += new TurretSimPlayerHandler(TurretsController.DoUpgradeTurret);
PlanetarySystemController.ObjectDestroyed += new PhysicalObjectHandler(TurretsController.DoObjectDestroyed);
PlanetarySystemController.ObjectDestroyed += new PhysicalObjectHandler(SimPlayersController.DoObjectDestroyed);
SimPlayersController.NextWaveAsked += new NoneHandler(EnemiesController.DoNextWaveAsked);
SpaceshipsController.ObjectCreated += new PhysicalObjectHandler(BulletsController.DoObjectCreated);
SpaceshipsController.ObjectCreated += new PhysicalObjectHandler(SimPlayersController.DoObjectCreated);
PlanetarySystemController.ObjectDestroyed += new PhysicalObjectHandler(CollisionsController.DoObjectDestroyed);
SpaceshipsController.ObjectCreated += new PhysicalObjectHandler(CollisionsController.DoObjectCreated);
EnemiesController.ObjectCreated += new PhysicalObjectHandler(CollisionsController.DoObjectCreated);
PlanetarySystemController.ObjectHit += new PhysicalObjectHandler(LevelsController.DoObjectHit);
PlanetarySystemController.ObjectDestroyed += new PhysicalObjectHandler(LevelsController.DoObjectDestroyed);
EnemiesController.EnemyReachedEndOfPath += new EnemyCelestialBodyHandler(this.DoEnemyReachedEndOfPath);
PlanetarySystemController.ObjectDestroyed += new PhysicalObjectHandler(this.DoCelestialBodyDestroyed);
SimPlayersController.CommonStashChanged += new CommonStashHandler(GUIController.DoCommonStashChanged);
LevelsController.NewGameState += new NewGameStateHandler(GUIController.DoGameStateChanged);
SimPlayersController.PlayerSelectionChanged += new SimPlayerHandler(GUIController.DoPlayerSelectionChanged);
SimPlayersController.PlayerSelectionChanged += new SimPlayerHandler(this.DoPlayerSelectionChanged);
TurretsController.TurretReactivated += new TurretHandler(SimPlayersController.DoTurretReactivated);
SimPlayersController.PlayerMoved += new SimPlayerHandler(GUIController.DoPlayerMoved);
LevelsController.NewGameState += new NewGameStateHandler(this.DoNewGameState); //must come after GUIController.DoGameStateChanged
LevelsController.CommonStashChanged += new CommonStashHandler(GUIController.DoCommonStashChanged);
SimPlayersController.TurretToPlaceSelected += new TurretSimPlayerHandler(GUIController.DoTurretToPlaceSelected);
SimPlayersController.TurretToPlaceDeselected += new TurretSimPlayerHandler(GUIController.DoTurretToPlaceDeselected);
SimPlayersController.BuyTurretAsked += new TurretSimPlayerHandler(GUIController.DoTurretBought);
SimPlayersController.SellTurretAsked += new TurretSimPlayerHandler(GUIController.DoTurretSold);
SimPlayersController.ActivatePowerUpAsked += new PowerUpTypeSimPlayerHandler(PowerUpsController.DoActivatePowerUpAsked);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(SpaceshipsController.DoPowerUpStarted);
PowerUpsController.PowerUpStopped += new PowerUpSimPlayerHandler(SpaceshipsController.DoPowerUpStopped);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(GUIController.DoPowerUpStarted);
PowerUpsController.PowerUpStopped += new PowerUpSimPlayerHandler(GUIController.DoPowerUpStopped);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(SimPlayersController.DoPowerUpStarted);
PowerUpsController.PowerUpStopped += new PowerUpSimPlayerHandler(SimPlayersController.DoPowerUpStopped);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(CollisionsController.DoPowerUpStarted);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(BulletsController.DoPowerUpStarted);
PowerUpsController.PowerUpStopped += new PowerUpSimPlayerHandler(BulletsController.DoPowerUpStopped);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(PlanetarySystemController.DoPowerUpStarted);
PowerUpsController.PowerUpStopped += new PowerUpSimPlayerHandler(PlanetarySystemController.DoPowerUpStopped);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(LevelsController.DoPowerUpStarted);
CollisionsController.TurretBoosted += new TurretTurretHandler(TurretsController.DoTurretBoosted);
SimPlayersController.PlayerMoved += new SimPlayerHandler(PowerUpsController.DoPlayerMoved);
LevelsController.NewGameState += new NewGameStateHandler(PowerUpsController.DoNewGameState);
TurretsController.ObjectCreated += new PhysicalObjectHandler(SimPlayersController.DoObjectCreated);
CollisionsController.BulletDeflected += new EnemyBulletHandler(BulletsController.DoBulletDeflected);
BulletsController.ObjectDestroyed += new PhysicalObjectHandler(TurretsController.DoObjectDestroyed);
SimPlayersController.DesactivatePowerUpAsked += new PowerUpTypeSimPlayerHandler(PowerUpsController.DoDesactivatePowerUpAsked);
SimPlayersController.PlayerConnected += new SimPlayerHandler(GUIController.DoPlayerConnected);
SimPlayersController.PlayerDisconnected += new SimPlayerHandler(GUIController.DoPlayerDisconnected);
SimPlayersController.PlayerConnected += new SimPlayerHandler(PowerUpsController.DoPlayerConnected);
SimPlayersController.PlayerDisconnected += new SimPlayerHandler(PowerUpsController.DoPlayerDisconnected);
SimPlayersController.PlayerConnected += new SimPlayerHandler(PanelsController.DoPlayerConnected);
SimPlayersController.PlayerDisconnected += new SimPlayerHandler(PanelsController.DoPlayerDisconnected);
SimPlayersController.ShowAdvancedViewAsked += new SimPlayerHandler(GUIController.DoShowAdvancedViewAsked);
SimPlayersController.HideAdvancedViewAsked += new SimPlayerHandler(GUIController.DoHideAdvancedViewAsked);
CollisionsController.ObjectHit += new PhysicalObjectPhysicalObjectHandler(SimPlayersController.DoObjectHit);
SimPlayersController.PlayerConnected += new SimPlayerHandler(EditorController.DoPlayerConnected);
SimPlayersController.PlayerDisconnected += new SimPlayerHandler(EditorController.DoPlayerDisconnected);
EditorController.PlayerConnected += new EditorPlayerHandler(EditorGUIController.DoPlayerConnected);
EditorController.PlayerDisconnected += new EditorPlayerHandler(EditorGUIController.DoPlayerDisconnected);
SimPlayersController.PlayerMoved += new SimPlayerHandler(EditorController.DoPlayerMoved);
EditorController.PlayerChanged += new EditorPlayerHandler(EditorGUIController.DoPlayerChanged);
EditorController.EditorCommandExecuted += new EditorCommandHandler(PlanetarySystemController.DoEditorCommandExecuted); //must be executed before sync of gui
EditorController.EditorCommandExecuted += new EditorCommandHandler(EditorGUIController.DoEditorCommandExecuted);
EditorController.EditorCommandExecuted += new EditorCommandHandler(PowerUpsController.DoEditorCommandExecuted); //must be done before the Players Controller
EditorController.EditorCommandExecuted += new EditorCommandHandler(SimPlayersController.DoEditorCommandExecuted); //must be done before the GUI
EditorController.EditorCommandExecuted += new EditorCommandHandler(LevelsController.DoEditorCommandExecuted); // must be donne before the GUI
EditorController.EditorCommandExecuted += new EditorCommandHandler(GUIController.DoEditorCommandExecuted);
SimPlayersController.ObjectCreated += new PhysicalObjectHandler(BulletsController.DoObjectCreated);
LevelsController.NewGameState += new NewGameStateHandler(PanelsController.DoGameStateChanged);
PanelsController.PanelOpened += new NoneHandler(GUIController.DoPanelOpened);
PanelsController.PanelClosed += new NoneHandler(GUIController.DoPanelClosed);
EnemiesController.ObjectDestroyed += new PhysicalObjectHandler(GUIController.DoObjectDestroyed);
EnemiesController.NextWaveCompositionChanged += new NextWaveHandler(GUIController.DoNextWaveCompositionChanged);
LevelsController.NewGameState += new NewGameStateHandler(SimPlayersController.DoNewGameState);
CollisionsController.PlayersCollided += new SimPlayerSimPlayerHandler(SimPlayersController.DoPlayersCollided);
CollisionsController.PlayersCollided += new SimPlayerSimPlayerHandler(AudioController.DoPlayersCollided);
CollisionsController.StartingPathCollision += new BulletCelestialBodyHandler(BulletsController.DoStartingPathCollision);
CollisionsController.StartingPathCollision += new BulletCelestialBodyHandler(GUIController.DoStartingPathCollision);
CollisionsController.StartingPathCollision += new BulletCelestialBodyHandler(AudioController.DoStartingPathCollision);
CollisionsController.ShieldCollided += new CollidableBulletHandler(SpaceshipsController.DoShieldCollided);
CollisionsController.ShieldCollided += new CollidableBulletHandler(BulletsController.DoShieldCollided);
BulletsController.ObjectDestroyed += new PhysicalObjectHandler(AudioController.DoObjectDestroyed);
EnemiesController.WaveStarted += new NoneHandler(AudioController.DoWaveStarted);
PowerUpsController.PowerUpStarted += new PowerUpSimPlayerHandler(AudioController.DoPowerUpStarted);
PowerUpsController.PowerUpStopped += new PowerUpSimPlayerHandler(AudioController.DoPowerUpStopped);
TurretsController.TurretBought += new TurretSimPlayerHandler(AudioController.DoTurretBought);
TurretsController.TurretSold += new TurretSimPlayerHandler(AudioController.DoTurretSold);
TurretsController.TurretFired += new TurretHandler(AudioController.DoTurretFired);
TurretsController.TurretReactivated += new TurretHandler(AudioController.DoTurretReactivated);
PowerUpsController.PowerUpInputCanceled += new PowerUpSimPlayerHandler(AudioController.DoPowerUpInputCanceled);
PowerUpsController.PowerUpInputPressed += new PowerUpSimPlayerHandler(AudioController.DoPowerUpInputPressed);
PowerUpsController.PowerUpInputReleased += new PowerUpSimPlayerHandler(AudioController.DoPowerUpInputReleased);
EnemiesController.ObjectHit += new PhysicalObjectHandler(AudioController.DoObjectHit);
EnemiesController.ObjectDestroyed += new PhysicalObjectHandler(AudioController.DoObjectDestroyed);
PlanetarySystemController.ObjectHit += new PhysicalObjectHandler(AudioController.DoObjectHit);
PlanetarySystemController.ObjectDestroyed += new PhysicalObjectHandler(AudioController.DoObjectDestroyed);
SimPlayersController.PlayerBounced += new SimPlayerHandler(AudioController.DoPlayerBounced);
TurretsController.TurretWandered += new TurretHandler(AudioController.DoTurretWandered);
TurretsController.TurretUpgraded += new TurretSimPlayerHandler(AudioController.DoTurretUpgraded);
BulletsController.BulletDeflected += new BulletHandler(AudioController.DoBulletDeflected);
EnemiesController.WaveNearToStart += new NoneHandler(AudioController.DoWaveNearToStart);
SimPlayersController.PlayerConnected += new SimPlayerHandler(AudioController.DoPlayerConnected);
SimPlayersController.PlayerDisconnected += new SimPlayerHandler(AudioController.DoPlayerDisconnected);
EnemiesController.WaveEnded += new NoneHandler(AudioController.DoWaveEnded);
SimPlayersController.PlayerFired += new SimPlayerHandler(AudioController.DoPlayerFired);
SimPlayersController.PlayerSelectionChanged += new SimPlayerHandler(AudioController.DoPlayerSelectionChanged);
SimPlayersController.PlayerActionRefused += new SimPlayerHandler(AudioController.DoPlayerActionRefused);
Main.CheatsController.CheatActivated += new StringHandler(DoCheatActivated);
Main.Options.ShowHelpBarChanged += new BooleanHandler(DoShowHelpBarChanged);
}
public virtual void SelectLevel(LevelSelectScreenViewModel viewModel, LevelDescriptor arg)
{
}
public virtual void ExecuteSelectLevel(LevelDescriptor arg)
{
LevelSelectScreen.SelectLevel.OnNext(new SelectLevelCommand() { Sender = LevelSelectScreen, Argument = arg });
}
public virtual void AvailableLevelsOnRemove(LevelDescriptor arg1)
{
}
public virtual void AvailableLevelsOnAdd(LevelDescriptor arg1)
{
}
public virtual void ExecuteSelectLevel(LevelDescriptor argument) {
this.SelectLevel.OnNext(new SelectLevelCommand(){Argument = argument});
}
private void Start()
{
SceneManager.sceneLoaded += OnSceneLoaded;
CurrentLevel = FindLevelDescriptorForCurrentScene();
}
public virtual void SelectLevel(LevelSelectScreenViewModel viewModel, LevelDescriptor arg)
{
}
public Level(Simulator simulator, LevelDescriptor descriptor)
{
Simulator = simulator;
Descriptor = descriptor;
}
public virtual void AvailableLevelsOnRemove(LevelDescriptor arg1)
{
}
