public ActionResult Delete(int modelId)
{
try
{
using (ISession session = NHibernateHelper.OpenSession())
{
LevelModel model = session.Get <LevelModel>(modelId);
using (ITransaction transaction = session.BeginTransaction())
{
session.Delete(model);
transaction.Commit();
}
}
return(RedirectToAction("Index").WithMessage(Languages.Success, "alert-success", "glyphicon glyphicon-ok-sign"));
}
catch (ADOException)
{
return(RedirectToAction("Index").WithMessage(Languages.ADOException, "alert-warning", "glyphicon glyphicon-exclamation-sign"));
throw;
}
catch (System.Exception)
{
return(RedirectToAction("Index").WithMessage(Languages.Error, "alert-danger", "glyphicon glyphicon-remove-sign"));
throw;
}
}
public void ChangeCylinderSound(LevelModel levelModel)
{
if (levelModel.CylinderSound == SoundType.SlowBreath)
{
cylinderSoundsSource.clip = breathClips[0];
}
else if (levelModel.CylinderSound == SoundType.FastBreath)
{
cylinderSoundsSource.clip = breathClips[1];
}
else if (levelModel.CylinderSound == SoundType.Scream)
{
cylinderSoundsSource.clip = breathClips[2];
}
cylinderSoundsSource.loop = true;
if (levelModel.CylinderSound == SoundType.Disabled)
{
cylinderSoundsSource.Stop();
}
else
{
cylinderSoundsSource.Play();
}
}
public IActionResult Index(int?lvlid = 1, int?id = 4)
{
// штука для проверки аутентификации
if (HttpContext.Session.Get <bool>(CacheKeys.LoggedIn))
{
level = null;
}
level = null;
userInventory = null;
CacheLoad(lvlid ?? default(int));
Inventory inv = new Inventory();
// Текущая сцена
var currentScene = level.Scenes.FirstOrDefault(sc => sc.Id == id);
var model = new SceneListModel()
{
Scenes = level.Scenes,
CurrentScene = currentScene,
InventoryItems = userInventory,
Inventory = inv,
RemainingTime = 900,
LevelId = lvlid
};
return(View(model));
}
public ActionResult Create(LevelModel model, int Institution)
{
try
{
using (ISession session = NHibernateHelper.OpenSession())
{
InstitutionModel institutionModel = session.Get <InstitutionModel>(Institution);
model.Institution = institutionModel;
using (ITransaction transaction = session.BeginTransaction())
{
session.Save(model);
transaction.Commit();
}
}
return(RedirectToAction("Index").WithMessage(Languages.Success, "alert-success", "glyphicon glyphicon-ok-sign"));
}
catch
{
return(RedirectToAction("Index").WithMessage(Languages.Error, "alert-danger", "glyphicon glyphicon-remove-sign"));
throw;
}
}
public void Update(int id, LevelModel model)
{
var level = _repo.Get <Level>(model.LevelId);
var entity = model.Edit(level, model);
_repo.Update <Level>(model.LevelId, entity);
}
public void EnterChapter(LevelModel levelModel)
{
_levelModel = levelModel;
_currentChapterId = levelModel.ActiveLevel.ChapterGroup;
List <Dropdown.OptionData> options = new List <Dropdown.OptionData>();
for (int i = 0; i < levelModel.ChapterList.Count; i++)
{
Dropdown.OptionData opt =
new Dropdown.OptionData(levelModel.ChapterList[i].ChapterName + "·" +
levelModel.ChapterList[i].ChapterDesc);
options.Add(opt);
}
_dropdown.options = options;
if (_dropdown.value == _currentChapterId - 1)
{
OnSelectChapter(_currentChapterId - 1);
}
else
{
_dropdown.value = _currentChapterId - 1;
}
}
public void SaveLevelData(LevelModel pLvlModel)
{
string levelScoreKey = LevelScoreKey + pLvlModel.LevelNo;
if (PlayerPrefs.HasKey(levelScoreKey))
{
int oldScore = PlayerPrefs.GetInt(levelScoreKey);
if (pLvlModel.Score > oldScore)
{
PlayerPrefs.SetInt(levelScoreKey, pLvlModel.Score);
}
}
else
{
PlayerPrefs.SetInt(levelScoreKey, pLvlModel.Score);
}
if (PlayerPrefs.HasKey(LevelsCompletedKey))
{
if (pLvlModel.LevelNo > PlayerPrefs.GetInt(LevelsCompletedKey))
{
PlayerPrefs.SetInt(LevelsCompletedKey, pLvlModel.LevelNo);
}
}
else
{
PlayerPrefs.SetInt(LevelsCompletedKey, pLvlModel.LevelNo);
}
}
public void UpdateCheckPoint(int lv = 301)
{
this.Model.LoadScore();
using (List <G3LevelItem> .Enumerator enumerator = this.CheckPoints.GetEnumerator())
{
while (enumerator.MoveNext())
{
enumerator.Current.gameObject.SetActive(false);
}
}
List <string> list = this.Model.GetcheckPointByLv(lv);
if (list.Count > 0)
{
int num = 0;
int dot_val = list.Count / 20;
for (int k = 0; k < dots.Length; k++)
{
dots[k].SetActive(dot_val >= k);
}
foreach (string current in list)
{
LevelModel tG = this.Model.levelConfig[current];
if (this.CheckPoints.Count - 1 < num)
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(Resources.Load("Prefabs/G00300") as GameObject);
gameObject.SetActive(true);
gameObject.transform.SetParent(this.gameboxs[num / 20].transform, false);
this.CheckPoints.Add(gameObject.GetComponent <G3LevelItem>());
}
this.CheckPoints[num].gameObject.SetActive(true);
this.CheckPoints[num].Init(num + 1, num, current);
this.CheckPoints[num].SetCheckpointStatus(tG.ID <= this.Model.Lv_score[lv.ToString()] + 1);
this.CheckPoints[num].Setnow(tG.ID == this.Model.Lv_score[lv.ToString()] + 1);
num++;
}
for (int k = 0; k < gameboxs.Length; k++)
{
int ten = this.Model.Lv_score[lv.ToString()] % 100 / 10;
int one = this.Model.Lv_score[lv.ToString()] % 10;
gameboxs[k].SetActive((ten * 10 + one) / 20 == k);
content = (ten * 10 + one) / 20;
}
Check_Dot();
if (this.Model.Lv_score[lv.ToString()] == 0)
{
this.CheckPoints[0].SetCheckpointStatus(true);
this.CheckPoints[0].Setnow(true);
}
}
this.UpdateLv();
}
private LevelModel GetLocaFromLevel()
{
LevelModel lm = new LevelModel();
//Get the server data and paste into a string
WebClient myClient = new WebClient();
Stream response =
myClient.OpenRead(MainVM.Settings.GetAddress(isProd, LevelId, AccessToken));
StreamReader sr = new StreamReader(response);
string str = sr.ReadToEnd();
//Get all the dialog
bool notEnd = true;
while (notEnd)
{
int startIndex = str.IndexOf(MainVM.Settings.DialogStart);
if (startIndex > 0)
{
str = str.Substring(startIndex);
int endIndex = str.IndexOf(MainVM.Settings.DialogEnd);
lm.LocaKeys.Add(str.Substring(30, endIndex - 30));
str = str.Substring(endIndex);
}
else
{
notEnd = false;
}
}
lm.ID = LevelId;
return(lm);
}
public void SetData(UpgradeStarRequireVo vo, CardModel cardModel, LevelModel model, int cardId)
{
_propName.text = vo.PropName + "X" + vo.CurrentNum;
_propTexture.texture = ResourceManager.Load <Texture>(vo.GetPropTexturePath);
_jumpDataList = cardModel.GetJumpDataById(vo.PropId);
JumpTo(vo.PropId, vo.NeedNum, cardModel, model, cardId);
}
public Task InsertLevel(LevelModel level)
{
string sql = @"insert into dbo.Level (LevelNum, NumStacks, Stack1, Stack2, Stack3, Stack4, Stack5, Stack6, Stack7, Stack8, Stack9, Stack10)
values (@LevelNum, @NumStacks, @Stack1, @Stack2, @Stack3, @Stack4, @Stack5, @Stack6, @Stack7, @Stack8, @Stack9, @Stack10);";
return(_db.SaveData(sql, level));
}
private void MapData(string data)
{
string zonesJsonFile = System.IO.File.ReadAllText(_configuration[$"JsonData:{data}"]);
List <ZoneModelMapper> zoneMapperData = new List <ZoneModelMapper>();
List <ZoneModel> zoneData = new List <ZoneModel>();
zoneMapperData = JsonConvert.DeserializeObject <List <ZoneModelMapper> >(zonesJsonFile);
foreach (var model in zoneMapperData)
{
if (String.IsNullOrEmpty(model.Level[0]) || String.IsNullOrEmpty(model.Level[1]))
{
model.Level[0] = 0.ToString();
model.Level[1] = 0.ToString();
}
var level = new LevelModel
{
Level1 = Int32.Parse(model?.Level[0]),
Level2 = Int32.Parse(model?.Level[1])
};
var mapping = new ZoneModel
{
Id = model.Id,
Category = model.Category,
ZoneId = model.ZoneId,
Level = level,
Name = model.Name,
Territory = model.Territory
};
_database.Add(mapping);
_database.SaveChanges();
}
}
public void test7_Player_Can_Walk_NORTH_SOUTH_EAST_WEST_From_Provider
(int playPositionX, int playPositionY, int mapSize, bool expectedResult, LevelModel.CompassDirection direction)
{
//Arrange
LevelModel m = new LevelModel(mapSize);
m.map[1, 2] = LevelModel.SquareType.EMPTY_H0;
m.map[2, 2] = LevelModel.SquareType.EMPTY_H0;
m.map[2, 3] = LevelModel.SquareType.EMPTY_H0;
m.map[1, 2] = LevelModel.SquareType.EMPTY_H0;
m.map[1, 2] = LevelModel.SquareType.EMPTY_H0;
m.playerX = playPositionX;
m.playerY = playPositionY;
m.Walk(direction);
//Act
bool result = m.GetLastActionSuccess();
//Assert
Assert.AreEqual(expectedResult, result);
}
public override OperateResult Delete(Guid id)
{
var r = base.Delete(id);
LevelModel.Load();
return(r);
}
//private LevelView2 view2
void Start()
{
//Text File Class
textFile = new LevelLayoutFromTextFile();
textFile.ReadTextFile();
//model
model = new LevelModel(18);
// Controller
/*
* controller = new LevelController();
* controller.SetModel(model);
* controller.SetView(view);
*/
inputController = new InputController();
inputController.SetModel(model);
// View
view = new LevelView();
// view.SetModel(model);
view.SetTextFile(textFile);
// view.Refresh();
// view.UpdateTextDisplay(z);
}
string SaveGemMap()
{
var tileMap = level.tileMap;
var gravityMap = level.gravityMap;
var gemMap = level.gemMap;
int cols = (int)level.mapSize.x;
int rows = (int)level.mapSize.y;
var countOfItem = cols * rows;
var tiles = new int[countOfItem];
var gravities = new int[countOfItem];
var gems = new int[countOfItem];
for (var i = 0; i < countOfItem; i++)
{
tiles[i] = tileMap.root.transform.Find("item_" + i).GetComponent <ItemInfo>().ID;
gravities[i] = gravityMap.root.transform.Find("item_" + i).GetComponent <ItemInfo>().ID;
gems[i] = gemMap.root.transform.Find("item_" + i).GetComponent <ItemInfo>().ID;
}
var levelModel = new LevelModel {
cols = cols,
rows = rows,
moves = level.moves,
gems = gems,
tiles = tiles,
gravities = gravities,
gemTypesAvailable = level.gemTypesAvailable,
missions = level.missions
};
return(JsonUtility.ToJson(levelModel, true));
}
public async Task <LevelModel> Execute(LevelModel model)
{
var level = _mapper.Map <LevelModel, Level>(model);
var addedLevel = await _levelRepository.Create(level);
return(_mapper.Map <Level, LevelModel>(addedLevel));
}
public void Attach(LevelModel model_)
{
_model = model_;
_model.OnEnemyCreate += SpawnEnemy;
_model.OnHeroCreate += SpawnHero;
_model.OnStartEnemyWave += OnEnemyWaveStart;
}
public void Init(LevelModel level)
{
_level = level;
EventManager.Get <HeroDeathEvent>().Subscribe(OnHeroDeath);
EventManager.Get <HeroSpawnEvent>().Subscribe(OnHeroSpawn);
InitLevelIndicators();
}
public static List <LevelTile> GetAdjacentTiles(LevelModel model, int xPosition, int zPosition)
{
List <LevelTile> tiles = new List <LevelTile>();
for (int x = (int)xPosition - 1; x <= (int)xPosition + 1; ++x)
{
if (!LevelHelpers.TileIsInBounds(model, x, zPosition))
{
continue;
}
tiles.Add(model.Tiles[x, zPosition]);
}
for (int z = (int)zPosition - 1; z <= (int)zPosition + 1; ++z)
{
if (!LevelHelpers.TileIsInBounds(model, xPosition, z))
{
continue;
}
tiles.Add(model.Tiles[xPosition, z]);
}
return(tiles);
}
public static void DeleteYear(int year)
{
TrimesterCommentModel.DeleteAll(year);
TrimesterSubjectCommentModel.DeleteAll(year);
SemiTrimesterCommentModel.DeleteAll(year);
PeriodCommentModel.DeleteAll(year);
MarkModel.DeleteAll(year);
TeacherClassModel.DeleteAll(year);
LevelSubjectModel.DeleteAll(year);
SubjectTeacherModel.DeleteAll(year);
SemiTrimesterModel.DeleteAll(year);
PeriodModel.DeleteAll(year);
StudentModel.DeleteAll(year);
ClassModel.DeleteAll(year);
LevelModel.DeleteAll(year);
SubjectModel.DeleteAll(year);
TeacherModel.DeleteAll(year);
YearParametersModel.DeleteAll(year);
YearModel.Delete(year);
MessageBox.Show("Suppresion de l'année réussie.", "Réussite", MessageBoxButton.OK, MessageBoxImage.Information);
MainViewModel.Instance.LoadYears();
MainViewModel.Instance.SelectedYear = year - 1;
}
// Use this for initialization
public void Initialize(LevelModel pLvlModel)
{
if (pLvlModel != null)
{
LevelMdl = pLvlModel;
}
IsActive = true;
MainCanvas = GameObject.FindGameObjectWithTag("MainCanvas").transform;
UIPos = GameObject.FindGameObjectWithTag("UIPos").transform;
StandardShader = Shader.Find("Standard");
ActivateSparkParticleEffect();
var highlightable = transform.Find("Highlightable");
foreach (var renderer in highlightable.GetComponentsInChildren <Renderer>())
{
HighlightMaterials.AddRange(renderer.materials);
}
foreach (Material mat in HighlightMaterials)
{
mat.color = Color.green;
}
}
public override Guid Insert(StaffLevel entity)
{
var g = base.Insert(entity);
LevelModel.Load();
return(g);
}
internal static void SaveGame(string p, LevelModel levelModel)
{
XmlDocument doc = new XmlDocument();
XmlDeclaration xmlDeclaration = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
XmlElement root = doc.DocumentElement;
doc.InsertBefore(xmlDeclaration, root);
XmlElement saveNode = doc.CreateElement(string.Empty, "save", string.Empty);
doc.AppendChild(saveNode);
XmlElement levelNode = doc.CreateElement(string.Empty, "level", string.Empty);
levelNode.Attributes.Append(createAttribute(doc, "name", levelModel.level.Name));
levelNode.Attributes.Append(createAttribute(doc, "x", (levelModel.Avatar.X / Constants.TILE_SIZE).ToString()));
levelNode.Attributes.Append(createAttribute(doc, "y", (levelModel.Avatar.Y / Constants.TILE_SIZE).ToString()));
saveNode.AppendChild(levelNode);
XmlElement investigationNode = doc.CreateElement(string.Empty, "investigation", string.Empty);
saveNode.AppendChild(investigationNode);
foreach (KeyValuePair <string, bool> info in Game.knowledge)
{
XmlElement factNode = doc.CreateElement(string.Empty, "fact", string.Empty);
factNode.Attributes.Append(createAttribute(doc, "id", info.Key));
factNode.InnerText = info.Value.ToString();
investigationNode.AppendChild(factNode);
}
doc.Save("../../Resources/" + p + ".xml");
}
void InitLevel(string[] rows)
{
GameFieldModel fieldModel = new GameFieldModel(rows);
PlayerModel playerModel = new PlayerModel(new FieldBounds(fieldModel.Width, fieldModel.Height),
TileUtility.GetTiles(TileType.Body, fieldModel.Tiles));
GameFieldView fieldView = gameField.GetComponent <GameFieldView> ();
Player playerView = player.GetComponent <Player> ();
PlayerController playerController = new PlayerController(playerModel, playerView);
GameFieldController gameFieldController = new GameFieldController(fieldModel, fieldView);
LevelModel levelModel = new LevelModel();
LevelView levelView = GetComponent <LevelView> ();
StepTimer tickTimer = GetComponent <StepTimer> ();
StepTimerController timerController = new StepTimerController(levelModel, playerView, tickTimer);
StatusPanelView statusView = statusPanel.GetComponent <StatusPanelView> ();
StatusPanelController statusPanelController = new StatusPanelController(levelModel, statusView);
SpawnController spawnController = new SpawnController(fieldModel, playerModel);
LevelController levelController = new LevelController(playerModel, fieldModel, levelModel, levelView, tickTimer);
}
public void OnPointerUp(PointerEventData eventData)
{
string text = GetComponentInChildren <Text>().text;
using (UnityWebRequest request = UnityWebRequest.Get("http://127.0.0.1:8000/level-download?name=" + text))
{
request.SendWebRequest();
while (!request.isDone)
{
new WaitForSeconds(0.5f);
}
if (request.isNetworkError || request.isHttpError)
{
Debug.Log(request.error);
}
else
{
string responseBody = request.downloadHandler.text;
LevelModel level = JsonUtility.FromJson <LevelModel>(responseBody);
GlobalVariables.Reset();
GlobalVariables.CurrentLevel = level;
LoadDefaultTurretParams(level.turrets);
LoadAllTurretParams();
LoadEnemyParams(level.enemies);
MusicManager.PlayBattleMusic();
SceneManager.LoadScene("Scenes/GameScene", LoadSceneMode.Single);
}
}
}
public async Task <LevelModel> Execute(LevelModel model)
{
var level = _mapper.Map <LevelModel, Level>(model);
var updatedLevel = await _levelRepository.Edit(level);
return(_mapper.Map <Level, LevelModel>(updatedLevel));
}
public static LevelModel ReadFile(int id)
{
string jsonString;
JsonData itemData;
LevelModel model = new LevelModel();
TextAsset textAsset = (TextAsset)Resources.Load("data");
string jsonString2 = textAsset.text;
itemData = JsonMapper.ToObject(jsonString2);
model.Id = (int)itemData["levels"][id - 1]["id"];
model.LaserInterval = (int)itemData["levels"][id - 1]["laserInterval"];
model.LaserVelocity = (int)itemData["levels"][id - 1]["laserVelocity"];
model.CoinInterval = (int)itemData["levels"][id - 1]["coinInterval"];
model.CoinVelocity = (int)itemData["levels"][id - 1]["coinVelocity"];
model.IsBossEnabled = (bool)itemData["levels"][id - 1]["bossEnabled"];
model.DistanceNeeded = (int)itemData["levels"][id - 1]["distanceNeeded"];
model.Stars = (int)itemData["levels"][0]["stars"];
model.OneStarThreshold = (int)itemData["levels"][id - 1]["oneStarThreshold"];
model.TwoStarThreshold = (int)itemData["levels"][id - 1]["twoStarThreshold"];
model.ThreeStarThreshold = (int)itemData["levels"][id - 1]["threeStarThreshold"];
model.TreeSpeed = (int)itemData["levels"][id - 1]["treeSpeed"];
model.FloorSpeed = (int)itemData["levels"][id - 1]["floorSpeed"];
model.SkySpeed = (int)itemData["levels"][id - 1]["skySpeed"];
return(model);
}
public void Load(LevelModel model)
{
id = model.ID;
dep = model.Unlocks;
if (map.IsDone(id))
{
state = LevelState.Done;
}
else
{
if (map.IsUnlocked(id))
{
if (model.IsPremiumOnly)
{
state = LevelState.Premium;
}
else
{
state = LevelState.Open;
}
}
else
{
state = LevelState.Locked;
}
}
SetColor();
}
public static void EditEntry(LevelModel model)
{
using (var ctx = new BotsDbContext())
{
ctx.Entry(model).State = EntityState.Modified;
ctx.SaveChanges();
}
}
private void SetIsGameRunning(bool running)
{
isGameRunning = running;
Color c = startText.GetComponent<SpriteRenderer> ().material.color;
c.a = running ? 0 : 1;
startText.GetComponent<SpriteRenderer> ().material.color = c;
if (isGameRunning) {
LevelModel level = new LevelModel(levelZero);
levelRunner.SetLevel(level);
levelRunner.Reset();
}
}
public void SetLevel(LevelModel l)
{
level = l;
}
