public async Task <bool> UpdateLevel(LevelDto levelDto)
{
var level = Mapper.Map <ILevelDto, Level>(levelDto);
UnitOfWork.Repo.Update(level);
return(await UnitOfWork.SaveChanges() > 0);
}
private void spawnSprites(LevelDto levelData)
{
foreach (var spriteDto in levelData.sprites)
{
var newGameObject = new GameObject();
newGameObject.transform.parent = transform;
newGameObject.transform.name = spriteDto.Name;
var newSpriteRenderer = newGameObject.AddComponent <SpriteRenderer>();
newGameObject.transform.position = spriteDto.Position.ToVector3();
newGameObject.transform.rotation = spriteDto.Rotation.ToQuaterion();
newGameObject.transform.localScale = spriteDto.Scale.ToVector3();
newSpriteRenderer.color = spriteDto.Color.ToVector4();
newSpriteRenderer.sprite = AssetDatabase.LoadAssetAtPath <Sprite>(spriteDto.SpriteAssetPath);
newSpriteRenderer.sharedMaterial = AssetDatabase.LoadAssetAtPath <Material>(spriteDto.MaterialAssetPath);
newSpriteRenderer.sortingOrder = spriteDto.OrderInLayer;
newSpriteRenderer.drawMode = spriteDto.DrawMode;
newSpriteRenderer.tileMode = spriteDto.TileMode;
newSpriteRenderer.size = spriteDto.Size.ToVector2();
if (spriteDto.Collider2DType != null)
{
newSpriteRenderer.gameObject.AddComponent(spriteDto.Collider2DType);
}
if (spriteDto.PiekaMaterialAsset != null)
{
var objectWithMaterial = newSpriteRenderer.gameObject.AddComponent <ObjectWithMaterial>();
objectWithMaterial.PiekaMaterial =
AssetDatabase.LoadAssetAtPath <PiekaMaterial>(spriteDto.PiekaMaterialAsset);
objectWithMaterial.Apply();
}
}
}
public async Task <IActionResult> AddLevel(LevelDto levelDto)
{
var level = _mapper.Map <Level>(levelDto);
level.Id = Guid.NewGuid().ToString();
var result = await _levelService.Create(level);
return(JsonResponse.New(_mapper.Map <LevelDto>(result)));
}
public static LevelDefinition FromDto(LevelDto playerDto)
{
var level = CreateInstance <LevelDefinition>();
level.PowerUps = playerDto.PowerUps;
level.Rounds = playerDto.Rounds;
level.EnemiesList = playerDto.EnemiesList.Select(EnemiesDefinition.FromDto).ToList();
return(level);
}
public async Task <IActionResult> AddOrUpdate(int?id)
{
ILevelDto level = new LevelDto();
if (id != null)
{
level = await _levelBusiness.GetLevel(Convert.ToInt32(id));
}
return(View(level));
}
public SummaryView(LevelDto level5Dto, LevelDto level6Dto)
{
DataContext = this;
_eventAggregator = InstanceFactory.GetEventAggregatorInstance();
_eventAggregator.GetEvent <SummaryCalculateEvent>().Subscribe(CalculateCourseOutcome);
_level5Dto = level5Dto;
_level6Dto = level6Dto;
InitializeComponent();
CalculateCourseOutcome();
}
public async Task <LevelDto> UpdateLevel(LevelDto level)
{
var request = new RestRequest(Method.PUT);
request.Resource = @"levels/update";
request.RequestFormat = DataFormat.Json;
request.AddBody(level);
var response = await restClient.ExecuteTaskAsync(request);
return(Newtonsoft.Json.JsonConvert.DeserializeObject <LevelDto>(response.Content));
}
public static LevelDto MapLevelDto(this Level level)
{
var levelDto = new LevelDto
{
LevelID = level.ID,
Name = level.Name,
Skill = level.Skill,
IsActive = level.IsActive
};
return(levelDto);
}
public async Task <IActionResult> UpdateLevel(LevelDto leveldto)
{
if (ModelState.IsValid)
{
var updated = await _levelBusiness.UpdateLevel(leveldto);
if (updated)
{
return(Ok("updated successfully"));
}
}
return(BadRequest(ModelState));
}
public LevelView(LevelDto levelDto)
{
DataContext = this;
_eventAggregator = InstanceFactory.GetEventAggregatorInstance();
_eventAggregator.GetEvent <ModuleLoadEvent>().Subscribe(ModuleAddEvent);
_eventAggregator.GetEvent <LevelMarkChangeEvent>().Subscribe(ModuleMarkChangeEvent);
_levelController = new LevelController();
LevelAverage = 0;
InitializeComponent();
_levelDto = levelDto;
LoadLevelData(_levelDto.Id);
CalculateLevelAverage(_levelDto.Id);
loadModuleViews();
}
public async Task <IActionResult> AddOrUpdate(LevelDto levelDto)
{
if (levelDto.LevelId > 0)
{
await _levelBusiness.UpdateLevel(levelDto);
}
else
{
var levelParameter = new LevelParameter {
LevelName = levelDto.LevelName
};
await _levelBusiness.AddLevel(levelParameter);
}
return(RedirectToAction("GetAllLevels"));
}
private void spawnSpriteShapes(LevelDto levelData)
{
foreach (var spriteShapeControllerDto in levelData.SpriteShapeControllers)
{
var newGameObject = new GameObject();
newGameObject.transform.parent = transform;
newGameObject.transform.name = spriteShapeControllerDto.Name;
var newSpriteShapeController = newGameObject.AddComponent <SpriteShapeController>();
newGameObject.transform.position = spriteShapeControllerDto.Position.ToVector3();
newGameObject.transform.rotation = spriteShapeControllerDto.Rotation.ToQuaterion();
newGameObject.transform.localScale = spriteShapeControllerDto.Scale.ToVector3();
newSpriteShapeController.splineDetail = spriteShapeControllerDto.SplineDetail;
newSpriteShapeController.spline.isOpenEnded = spriteShapeControllerDto.SplineDto.openEnded;
newSpriteShapeController.colliderDetail = spriteShapeControllerDto.ColliderDetail;
newSpriteShapeController.colliderOffset = spriteShapeControllerDto.ColliderOffset;
newSpriteShapeController.colliderCornerType = spriteShapeControllerDto.ColliderCornerType;
var index = 0;
foreach (var point in spriteShapeControllerDto.SplineDto.Points)
{
newSpriteShapeController.spline.InsertPointAt(index, point.Position.ToVector3());
newSpriteShapeController.spline.SetTangentMode(index, point.TangentMode);
newSpriteShapeController.spline.SetRightTangent(index, point.RightTangent.ToVector3());
newSpriteShapeController.spline.SetLeftTangent(index, point.LeftTangent.ToVector3());
index++;
}
if (spriteShapeControllerDto.Collider2DType != null)
{
newSpriteShapeController.gameObject.AddComponent(spriteShapeControllerDto.Collider2DType);
}
if (spriteShapeControllerDto.PiekaMaterialAsset != null)
{
var objectWithMaterial = newSpriteShapeController.gameObject.AddComponent <ObjectWithMaterial>();
objectWithMaterial.PiekaMaterial =
AssetDatabase.LoadAssetAtPath <PiekaMaterial>(spriteShapeControllerDto.PiekaMaterialAsset);
objectWithMaterial.Apply();
}
else
{
var spriteShape = AssetDatabase.LoadAssetAtPath <SpriteShape>(spriteShapeControllerDto.SpriteShapeAsset);
newSpriteShapeController.spriteShape = spriteShape;
}
newSpriteShapeController.BakeCollider();
}
}
public void Serialize()
{
var carSerialized = false;
var levelDto = new LevelDto();
for (int i = 0; i < transform.childCount; i++)
{
var spriteRenderer = transform.GetChild(i).GetComponent <SpriteRenderer>();
var spriteShapeController = transform.GetChild(i).GetComponent <SpriteShapeController>();
var prefab = transform.GetChild(i).GetComponent <ImPrefabSerializeMe>();
if (spriteRenderer != null)
{
levelDto.sprites.Add(new SpriteDto(spriteRenderer));
}
if (spriteShapeController != null)
{
levelDto.SpriteShapeControllers.Add(new SpriteShapeControllerDto(spriteShapeController));
}
if (prefab != null)
{
if (prefab.GetComponent <Car>() != null)
{
carSerialized = true;
}
levelDto.Prefabs.Add(new Prefab(prefab));
}
}
if (carSerialized)
{
var level = ScriptableObject.CreateInstance <Level>();
level.Json = Piekson.ToJson(levelDto);
AssetDatabase.CreateAsset(level,
"Assets/Levels/" + WorldType + "/" + SceneManager.GetActiveScene().name + ".asset");
Debug.Log(Piekson.ToJson(levelDto));
}
else
{
Debug.Log("Car is missing!");
}
}
/// <summary>
/// spawns prefabs
/// </summary>
/// <param name="levelData"></param>
/// <returns>True if car was spawned</returns>
private bool spawnPrefabs(LevelDto levelData)
{
var carWasSpawned = false;
foreach (var prefab in levelData.Prefabs)
{
var prefabAsset = AssetDatabase.LoadAssetAtPath <GameObject>(prefab.PrefabPath);
var newPrefab = Instantiate(prefabAsset, prefab.Position.ToVector3(), prefab.Rotation.ToQuaterion());
newPrefab.transform.name = prefab.Name;
newPrefab.transform.localScale = prefab.Scale.ToVector3();
newPrefab.transform.parent = transform;
if (newPrefab.GetComponent <Car>() != null)
{
carWasSpawned = true;
}
}
return(carWasSpawned);
}
public void Update(LevelDto levelData)
{
Reset();
Level = levelData.Level;
TotalSeconds = levelData.TotalSeconds;
SpriteName = levelData.SpriteName;
foreach (var dto in levelData.Objects)
{
Objects.Add(new ObjectModel
{
Id = dto.Id,
Name = dto.Name,
SpriteName = dto.SpriteName,
LocalX = dto.LocalX,
LocalY = dto.LocalY,
LocalScale = dto.LocalScale,
Rotation = dto.Rotation,
Collected = false
});
}
}
/// <summary>
/// Load all tabs with data
/// </summary>
/// <returns></returns>
private async Task LoadTabs()
{
ModuleLevelTab.Content = new ModuleLevelView(_courseId);
_level4Dto = await _levelController.GetLevelDetails(1, _courseId);
_level4Dto = _level4Dto == null ? new LevelDto() : _level4Dto;
_level4View = new LevelView(_level4Dto);
Level4Tab.Content = _level4View;
_level5Dto = await _levelController.GetLevelDetails(2, _courseId);
_level5Dto = _level5Dto == null ? new LevelDto() : _level5Dto;
_level5View = new LevelView(_level5Dto);
Level5Tab.Content = _level5View;
_level6Dto = await _levelController.GetLevelDetails(3, _courseId);
_level6Dto = _level6Dto == null ? new LevelDto() : _level6Dto;
_level6View = new LevelView(_level6Dto);
Level6Tab.Content = _level6View;
SummaryViewTab.Content = new SummaryView(_level5Dto, _level6Dto);
}
public void Save(LevelDto dto)
{
throw new NotImplementedException();
}
public async Task <LevelDto> Save(LevelDto levelDto)
{
var level = await httpClient.UpdateLevel(levelDto);
return(level);
}
public void Initialize(LevelDto levelDto)
{
Value = levelDto.Value;
Experience = levelDto.Experience;
}
