public async Task <IActionResult> Edit(int id, [Bind("ID,Nazov")] Complexity complexity)
{
if (id != complexity.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(complexity);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComplexityExists(complexity.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(complexity));
}
public void ComplexityToString_ReturnsValue()
{
var complexity = new Complexity(5);
string complexityText = complexity.ToString();
Assert.AreEqual("Complexity:5", complexityText, "Complexity ToString should return formated value.");
}
public Task(Priority priority, Complexity complexity, string descriptionName)
{
TaskId = ID++;
Priority = priority;
Complexity = complexity;
Description = descriptionName;
}
public void AddNewTask1()
{
TaskElement("Maintenance Spend - WTD").Clicks();
RemoveTask.WaitUntil();
RemoveTask.Clicks();
AddBtn.Clicks();
AddNewTask.Clicks();
TaskName.WaitUntil();
TaskName.EnterText("Test Task 1");
TaskTypeParent("Office Tasks").Clicks();
TaskTypeChild("Discipline").Clicks(); WaitforIt(Properties.VeryInactivePhase);
Complexity.SelectIndex(1); WaitforIt(Properties.VeryInactivePhase);
SaveTask.WaitUntil();
SaveTask.Clicks();
AddBtn.WaitUntil();
}
public void AddNewTask2()
{
WaitforIt(Properties.InactivePhase); AddBtn.WaitUntil();
AddBtn.Clicks();
AddNewTask.Clicks();
TaskName.WaitUntil();
TaskName.EnterText("Test Task 2");
TaskTypeParent("Office Tasks").Clicks();
TaskTypeChild("Discipline").Clicks(); WaitforIt(Properties.VeryInactivePhase);//WaitforIt(Properties.VeryInactivePhase)
Complexity.SelectIndex(1); WaitforIt(Properties.VeryInactivePhase);
SaveTask.WaitUntil();
SaveTask.Clicks();
AddBtn.WaitUntil();
}
public void AddNewTask4()
{
AddBtn.WaitUntil(); AddBtn.Clicks();
AddNewTask.Clicks();
TaskName.WaitUntil();
TaskName.EnterText("Unplanned Task 2");
TaskTypeParent("Office Tasks").Clicks();
TaskTypeChild("Discipline").Clicks(); WaitforIt(Properties.VeryInactivePhase);
Complexity.SelectIndex(1); WaitforIt(Properties.InactivePhase);
UCodeNewTask.WaitUntil();
UCodeNewTask.Clicks(); WaitforIt(Properties.VeryInactivePhase);
UCommentNewTask.EnterText("Unplanned2"); WaitforIt(Properties.InactivePhase);
SaveTask.WaitUntil();
SaveTask.Clicks(); WaitforIt(Properties.InactivePhase);
AddBtn.WaitUntil();
}
//удалить продукт
public void delElement(int id)
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
Complexity element = context.Complexities.FirstOrDefault(rec => rec.Id ==
id);
if (element != null)
{
context.Complexities.Remove(element);
context.SaveChanges();
}
else
{
throw new Exception("Элемент не найден");
}
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
// добавление нового товара
public void AddElement(Complexity model)
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
Complexity element = context.Complexities.FirstOrDefault(rec =>
rec.Id == model.Id);
if (element != null)
{
throw new Exception("Элемент с данным идентификатором уже существует");
}
element = new Complexity
{
Id = model.Id,
Name = model.Name
};
context.Complexities.Add(element);
context.SaveChanges();
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
public Result(int score, bool satisfyMinimumCriteria)
{
this.OriginalScore = score;
this.MeetMinimumRequirements = satisfyMinimumCriteria;
this.QualityState = Complexity.VeryWeak;
this.QualityState = getComplexity();
}
//public override decimal GetProximateDistance(int PeriodsAgo, IIndicatorValues Ind)
//{
// int period = (int)this.IndicatorParameters.List[0];
// int smoothingPeriod = (int)this.IndicatorParameters.List[1];
// List<decimal> ranges = new List<decimal>();
// for (int i = PeriodsAgo; i < (PeriodsAgo + period); i++)
// ranges.Add((decimal)Math.Abs((double)Ind.Complexity(period, smoothingPeriod)[i].FractalComplexity - (double)Ind.Complexity(period, smoothingPeriod)[i].FractalComplexity));
// return ranges.Average(); ;
//}
public override void GetAll(IIndicatorValues Ind)
{
int period = (int)this.IndicatorParameters.List[0];
int smoothingPeriod = (int)this.IndicatorParameters.List[1];
if (!Ind.Complexity(period, smoothingPeriod).IsPopulated)
{
int oldCurrentBar = Ind.Bar.CurrentBar;
for (int i = 1; i <= Ind.Bar.MaxBar; i++)
{
Ind.Bar.CurrentBar = i;
object prototype = null;
if (i == 1)
{
prototype = new Complexity();
}
else
{
prototype = (Complexity)Ind.Complexity(period, smoothingPeriod)[1].Clone();
}
Get(ref prototype, Ind);
Ind.Complexity(period, smoothingPeriod)[0] = (Complexity)prototype;
Ind.Complexity(period, smoothingPeriod).IsPopulated = true; // set here so instance is guaranteed to exits
}
Ind.Bar.CurrentBar = oldCurrentBar;
}
}
void UseEnums()
{
Complexity complexity = Complexity.Easy;
if (complexity == Complexity.Normal)
{
}
}
public Question GetQuestionByComplexity(Complexity complexity)
{
var questions = Questions.Where(x => x.Complexity == complexity).ToList();
var randomizer = new Random();
var position = randomizer.Next(0, questions.Count);
return(questions.ElementAt(position));
}
public Question(int id, QuestionType questionType, int score, string text, int surveyId, Complexity complexity)
{
Id = id;
QuestionType = questionType;
Score = score;
Text = text;
SurveyId = surveyId;
Complexity = complexity;
}
public QuestionWithOptionsResponse(int questionId, QuestionType questionType, int score, string text, Complexity complexity, OptionFull[] options)
{
QuestionId = questionId;
QuestionType = questionType;
Score = score;
Text = text;
Complexity = complexity;
Options = options;
}
void UseEnums()
{
// SelectionStatement select;
Complexity complexity = Complexity.Easy;
if (complexity == Complexity.Normal)
{
Console.WriteLine("Complexity normal");
}
}
public SudokuGame()
{
sudokuTable = new Table();
filledTable = new Table();
history = new Stack <KeyValuePair <TextBox, string> >();
redo = new Stack <KeyValuePair <TextBox, string> >();
gameStarted = false;
LOADED = false;
complexity = Complexity.EASY;
}
public GameDto GetGameDto(Complexity complexity)
{
var(size, colorsCount) = GetPatameters(complexity);
var cells = GetCell(size, colors.Take(colorsCount).ToArray());
var game = new GameDto(cells, false, true, size, size, Guid.NewGuid(), false, 0);
game.Complexity = complexity;
return(game);
}
void UserEnums()
{
SelectionStatement select;
Complexity complexity = Complexity.Easy;
if (complexity == Complexity.Normal)
{
}
}
public async Task <IActionResult> Create([Bind("ID,Nazov")] Complexity complexity)
{
if (ModelState.IsValid)
{
_context.Add(complexity);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(complexity));
}
private void GenerateCells(Complexity lComplexity)
{
Debug.Log("Generate Cells()");
// Cells depend on level of complexity
DeactivateCells();
for (int i = 0; i < (int)lComplexity; i++)
{
cells [i].SetActive(true);
}
gameWordsUIManager.SetupActiveCells((int)lComplexity);
}
static string GetResult(int speed, Complexity comp, User user)
{
bool isWin = false;
var reward = 0;
switch (comp)
{
case Complexity.Easy:
isWin = EasyRace(speed, user.Luck, ref reward);
break;
case Complexity.Normal:
isWin = NormalRace(speed, user.Luck, ref reward);
break;
case Complexity.Hard:
isWin = HardRace(speed, user.Luck, ref reward);
break;
}
string message;
var money = (int)(reward * (new Random().Next(90, 109) / (double)100) / 1.3);
if (isWin)
{
message = "@{0}, ты выиграл в гонке с компьютером и получил {1} опыта и {2} денег".Format(user.Login, reward, money);
if (comp == Complexity.Hard)
{
user.VictoriesWithAIHard++;
}
else if (comp == Complexity.Easy)
{
user.VictoriesWithAIEasy++;
}
else if (comp == Complexity.Normal)
{
user.VictoriesWithAINormal++;
}
else
{
user.VictoriesWithAI++;
}
}
else
{
message = "@{0}, ты проиграл в гонке с компьютером, утешительный приз - {1} опыта и {2} денег".Format(user.Login, reward, money);
}
user.RaceCountWithAI++;
user.Experience += reward;
user.Money += money;
return(message);
}
protected override string GetPresentDetail(IOutputInstant Instant, IIndicatorValues Data, IndicatorParameters IndicatorParameters)
{
Complexity fc = Data.Complexity(IndicatorParameters)[Instant.ExposureDate];
if (fc != null)
{
return(String.Format("{0}|", fc.FractalComplexity));
}
else
{
return(String.Format("{0}|", ""));
}
}
private void ComplexityChanged(object sender, EventArgs e)
{
CheckBox checkBox = sender as CheckBox;
Complexity complexity = (Complexity)checkBox.Tag;
if (checkBox.Checked)
{
Options.Complexity |= complexity;
}
else
{
Options.Complexity &= ~complexity;
}
}
public Course(CourseDto dto)
{
Name = dto.Name.Trim(Trimmers);
Url = dto.Url;
Format = (Format)dto.Format;
Complexity = (Complexity)dto.Complexity;
Practice = dto.Practice;
Free = dto.Free;
Length = dto.Length;
Feature = dto.Feature.Trim(Trimmers);
Content = dto.Content.Trim(Trimmers);
Depth = dto.Depth;
Competences = dto.Competences.Trim(Trimmers).ToLower().SplitArray();
}
public static void CreateTaskList()
{
Console.WriteLine("\nPlease enter the name of your task: ");
string taskName = Console.ReadLine();
Priority priority = Task_5_Priority.SetPriority();
Complexity complexity = Task_5_Complexity.SetComplexity();
TaskList.Add(new Tasks
{
TaskName = taskName,
TaskPriority = priority,
TaskDifficulty = complexity
});
}
private static void AddTaskToList(List <Task> tasks)
{
Console.Write("Please, enter the task description: ");
string description = Console.ReadLine();
Priority priority = InitPriority();
Complexity complexity = InitComplexity();
Task task = new Task(description, priority, complexity);
tasks.Add(task);
Console.WriteLine("The task is added to the list");
}
// Adds a single task to Task list.
public static void CreateTaskList()
{
Console.WriteLine("\nPlease enter the name of your task: ");
string taskName = Console.ReadLine();
Priority priority = PriorityHelper.SetPriority();
Complexity complexity = ComplexityHelper.SetComplexity();
TaskList.Add(new Task
{
TaskName = taskName,
Priority = priority,
Complexity = complexity
});
}
private static void MeasureAlgorithmsTime(object complexity)
{
Complexity complex = (Complexity)complexity;
switch (complex)
{
case Complexity.Optimistic:
Measure(randomValues, sortedValuesTimes);
break;
case Complexity.Pessimistic:
Measure(sortedValues, randomValuesTimes);
break;
}
}
public void AddTask(List <Task> tasks)
{
Console.WriteLine("Enter title.");
string name = Console.ReadLine();
Console.WriteLine("Enter complexity.");
Complexity complexity = EnumHelper.RequestForEnumValue <Complexity>();
Console.WriteLine("Enter priority.");
Priority priority = EnumHelper.RequestForEnumValue <Priority>();
Task task = new Task(name, priority, complexity);
tasks.Add(task);
}
public async Task <IActionResult> Create([Bind("Id,Name")] Complexity complexity)
{
bool isCreated = false;
if (ModelState.IsValid)
{
isCreated = _complexityService.Add(complexity);
}
if (isCreated)
{
return(RedirectToAction(nameof(Index)));
}
return(View(complexity));
}
internal void SetComplexity(Complexity complexity)
{
var numbers = (int)(_dimension * _dimension * _dimension * _dimension * (double)complexity / 100);
var random = new Random();
while (InvisibleNumbersCount()<numbers)
{
var numberIndex = random.Next(0, _dimension * _dimension * _dimension * _dimension - 1);
Numbers[numberIndex].IsVisible = false;
Numbers[numberIndex].IsMutable = true;
}
}
public string Run()
{
var complexity = new Complexity();
return string.Format("{0} {1}", complexity.PartA(), complexity.PartB());
}
/// <summary>
/// Ф-ция создания уровня.
/// Считывает данные из файла.
/// Файл должен быть с названием "lvlX.txt";
/// </summary>
/// <param name="lvl">номер уровня</param>
public void CreateLevel(int lvl)
{
blocks = new List<Block>();
objs = new List<Object>();
guards = new List<Guards>();
lasers = new List<Laser>();
cameras = new List<Cameras>();
interactionSubjects = new List<BaseObject>();
doors = new List<BaseObject>();
sysControls = new List<SysControl>();
NumberOfJewelry = 0;
string lvl_name = "content/lvls/lvl" + Convert.ToString(lvl) + ".txt";
string[] lines = File.ReadAllLines(lvl_name); //получили массив строк
// проверим уровень сложности
//if (lvl == 4)
complexity = Complexity.High;
//else
// complexity = Complexity.Low;
// индексы для заполнения карты
int indexI = 0;
int indexJ = 0;
int x = 0;
int y = 0;
string[] str = { };
int tempIndex = 0;
int[] sizeFile = new int[2];
// тестовый режим...
// ЕСЛИ УРОВЕНЬ ИЗ РЕДАКТОРА, ТО...
//приспособим загрузку уровней, сделанных в редакторе
if (lvl >= 1)
{
lines = File.ReadAllLines(lvl_name); //получили массив строк
//считываем размеры массива с уровнем (sizeFile[0] значение - строки, sizeFile[1] - колонки)
str = lines[0].Split(' ');
foreach (string s in str)
{
sizeFile[tempIndex] = Convert.ToInt32(s);
tempIndex++;
if (tempIndex == 2) { break; }
}
// выделим память для карты уровня
levelMap = new LevelObject[sizeFile[1] + 1, sizeFile[0] + 1];
//выделим память для дверей уровня
levelDoors = new LevelObject[sizeFile[1] + 1, sizeFile[0] + 1];
tempIndex = 0;
//считывание уровня из файла
for (int i = 0; i <= sizeFile[0]; i++) {
if (tempIndex == 0) { tempIndex++; continue; } // пропускаем первую строку с данными размера уровня
str = lines[i].Split(' ');
foreach (string s in str)
{
levelMap[indexI, indexJ] = LevelObject.Empty;
LevelObject obj = (LevelObject)Int32.Parse(s);
switch(obj)
{
case LevelObject.Empty:
levelMap[indexI, indexJ] = LevelObject.Empty;
break;
case LevelObject.Wall:
levelMap[indexI, indexJ] = LevelObject.Wall;
break;
case LevelObject.DoorHoriz:
levelMap[indexI, indexJ] = LevelObject.DoorHoriz;
levelDoors[indexI, indexJ] = LevelObject.DoorHoriz;
break;
case LevelObject.DoorVertic:
levelMap[indexI, indexJ] = LevelObject.DoorVertic;
levelDoors[indexI, indexJ] = LevelObject.DoorVertic;
break;
case LevelObject.DoorHorizOpen:
levelMap[indexI, indexJ] = LevelObject.DoorHorizOpen;
levelDoors[indexI, indexJ] = LevelObject.DoorHorizOpen;
break;
case LevelObject.DoorVerticOpen:
levelMap[indexI, indexJ] = LevelObject.DoorVerticOpen;
levelDoors[indexI, indexJ] = LevelObject.DoorVerticOpen;
break;
// деревянные двери
case LevelObject.DoorWoodHoriz:
levelMap[indexI, indexJ] = LevelObject.DoorWoodHoriz;
levelDoors[indexI, indexJ] = LevelObject.DoorWoodHoriz;
break;
case LevelObject.DoorWoodVertic:
levelMap[indexI, indexJ] = LevelObject.DoorWoodVertic;
levelDoors[indexI, indexJ] = LevelObject.DoorWoodVertic;
break;
case LevelObject.DoorWoodHorizOpen:
levelMap[indexI, indexJ] = LevelObject.DoorWoodHorizOpen;
levelDoors[indexI, indexJ] = LevelObject.DoorWoodHorizOpen;
break;
case LevelObject.DoorWoodVerticOpen:
levelMap[indexI, indexJ] = LevelObject.DoorWoodVerticOpen;
levelDoors[indexI, indexJ] = LevelObject.DoorWoodVerticOpen;
break;
case LevelObject.Guard:
levelMap[indexI, indexJ] = LevelObject.Guard;
break;
// кресла
case LevelObject.Chairs_U:
levelMap[indexI, indexJ] = LevelObject.Chairs_U;
break;
case LevelObject.Chairs_R:
levelMap[indexI, indexJ] = LevelObject.Chairs_R;
break;
case LevelObject.Chairs_D:
levelMap[indexI, indexJ] = LevelObject.Chairs_D;
break;
case LevelObject.Chairs_L:
levelMap[indexI, indexJ] = LevelObject.Chairs_L;
break;
// диваны
case LevelObject.Sofa_U:
levelMap[indexI, indexJ] = LevelObject.Sofa_U;
break;
case LevelObject.Sofa_R:
levelMap[indexI, indexJ] = LevelObject.Sofa_R;
break;
case LevelObject.Sofa_D:
levelMap[indexI, indexJ] = LevelObject.Sofa_D;
break;
case LevelObject.Sofa_L:
levelMap[indexI, indexJ] = LevelObject.Sofa_L;
break;
case LevelObject.Key:
levelMap[indexI, indexJ] = LevelObject.Key;
break;
// пластиковая карта
case LevelObject.Card:
levelMap[indexI, indexJ] = LevelObject.Card;
break;
// драгоценности для кражи
case LevelObject.Gold:
levelMap[indexI, indexJ] = LevelObject.Gold;
break;
case LevelObject.Rubin:
levelMap[indexI, indexJ] = LevelObject.Rubin;
break;
case LevelObject.Brilliant:
levelMap[indexI, indexJ] = LevelObject.Brilliant;
break;
// картины для кражи
case LevelObject.Picture1:
levelMap[indexI, indexJ] = LevelObject.Picture1;
break;
case LevelObject.Picture2:
levelMap[indexI, indexJ] = LevelObject.Picture2;
break;
case LevelObject.Picture3:
levelMap[indexI, indexJ] = LevelObject.Picture3;
break;
//стол управления камерами
case LevelObject.SpLU:
levelMap[indexI, indexJ] = LevelObject.SpLU;
break;
case LevelObject.SpUR:
levelMap[indexI, indexJ] = LevelObject.SpUR;
break;
case LevelObject.SpRD:
levelMap[indexI, indexJ] = LevelObject.SpRD;
break;
case LevelObject.SpDL:
levelMap[indexI, indexJ] = LevelObject.SpDL;
break;
// камеры
case LevelObject.CameraUL:
levelMap[indexI, indexJ] = LevelObject.CameraUL;
break;
case LevelObject.CameraUR:
levelMap[indexI, indexJ] = LevelObject.CameraUR;
break;
//стол с компьютером
case LevelObject.TableU:
levelMap[indexI, indexJ] = LevelObject.TableU;
break;
case LevelObject.TableR:
levelMap[indexI, indexJ] = LevelObject.TableR;
break;
case LevelObject.TableD:
levelMap[indexI, indexJ] = LevelObject.TableD;
break;
case LevelObject.TableL:
levelMap[indexI, indexJ] = LevelObject.TableL;
break;
// куст
case LevelObject.Plant:
levelMap[indexI, indexJ] = LevelObject.Plant;
break;
// лазеры
case LevelObject.LaserHoriz:
levelMap[indexI, indexJ] = LevelObject.LaserHoriz;
break;
case LevelObject.LaserVertic:
levelMap[indexI, indexJ] = LevelObject.LaserVertic;
break;
// движущиеся лазеры
case LevelObject.LaserHorizMoving:
levelMap[indexI, indexJ] = LevelObject.LaserHorizMoving;
break;
case LevelObject.LaserVerticMoving:
levelMap[indexI, indexJ] = LevelObject.LaserVerticMoving;
break;
// устанавливаем игрока и камеру в нач. позицию.
case LevelObject.Player:
int playerPosX = indexJ * size;
int playerPosY = indexI * size;
//размещаем игрока в начальную позицию
player.Position = new Rectangle(playerPosY, playerPosX, LevelLoader.SizePeople, LevelLoader.SizePeople);
camera.ScrollX = playerPosY - game.GetScreenWidth / 2 + size / 2;
camera.ScrollY = playerPosX - game.GetScreenHeight / 2 + size / 2;
// установка камеры в начальную позицию
if (camera.ScrollX < 0)
{
camera.ScrollX = 0;
}
if (camera.ScrollY < 0)
{
camera.ScrollY = 0;
}
if (camera.ScrollX > game.GetScreenWidth)
{
camera.ScrollX = game.GetScreenWidth;
}
if (camera.ScrollY > game.GetScreenHeight)
{
camera.ScrollY = game.GetScreenHeight;
}
break;
}
indexI++;
}
indexI = 0;
indexJ++;
}
indexI = 0;
indexJ = 0;
// выделим память для карты уровня
levelMapFloor = new LevelObject[sizeFile[1] + 1, sizeFile[0] + 1];
// выделим память для комнат уровня
levelMapRooms = new int[sizeFile[1] + 1, sizeFile[0] + 1];
//считывание пола с комнатами в игре
for (int i = sizeFile[0] + 1; i <= 2 * sizeFile[0]; i++)
{
str = lines[i].Split(' ');
foreach (string s in str)
{
levelMapFloor[indexI, indexJ] = LevelObject.Empty;
// пол в игре
if (s.Equals("1", StringComparison.OrdinalIgnoreCase))
{
levelMapFloor[indexI, indexJ] = LevelObject.Floor; // пол
levelMapRooms[indexI, indexJ] = Convert.ToInt32(s); // номер комнаты
}
indexI++;
}
indexI = 0;
indexJ++;
}
LevelObject[,] map = new LevelObject[sizeFile[1] + 1, sizeFile[0] + 1]; // карта уровня после преобразования
// преобразование значений объектов (стен) на уровне
for (int i = 0; i < sizeFile[1]; i++)
{
for (int j = 0; j < sizeFile[0]; j++)
{
map[i, j] = 0;
if (levelMap[i, j] == LevelObject.Wall)
{
map[i, j] = isWallType(levelMap, i, j, sizeFile[0] - 1, sizeFile[1] - 1);
}
}
}
// создание пола на уровне
// пол
// берется из 2 массива уровня в файле.
// 1 1 2 3 1 2
// ...........
// 1 2 3 4 1 2 - осн. массив уровня
// 90 90 90 90 - далее идет массив пола
// 0 90 90 0
// ..........
if (lvl >=1)// || lvl == 8)
{
for (int i = 0; i < sizeFile[1]; i++)
{
for (int j = sizeFile[0]; j <= 2 * sizeFile[0] - 1; j++)
{
Rectangle Rect = new Rectangle(i * LevelLoader.Size - LevelLoader.Size / 2, (j - sizeFile[0]) * LevelLoader.Size - LevelLoader.Size / 2, LevelLoader.Size, LevelLoader.Size);
//Rectangle Rect2 = new Rectangle((i + 1) * LevelLoader.Size - LevelLoader.Size / 2, (j - sizeFile[0]) * LevelLoader.Size - LevelLoader.Size / 2, LevelLoader.Size, LevelLoader.Size);
//Rectangle Rect3 = new Rectangle(i * LevelLoader.Size - LevelLoader.Size / 2, ((j - sizeFile[0]) + 1) * LevelLoader.Size - LevelLoader.Size / 2, LevelLoader.Size, LevelLoader.Size);
if (isFloor(levelMapFloor, i, j - sizeFile[0], sizeFile[1], sizeFile[0])) // i - колонки, j - строки
{
if (levelMapFloor[i, j - sizeFile[0]] == LevelObject.Floor)
{
Block block = new Block(Rect, storage.Pull2DTexture("floor"), game, this.camera);
blocks.Add(block);
Rectangle Rect2 = new Rectangle(i * LevelLoader.Size - LevelLoader.Size / 2, (j - sizeFile[0]) * LevelLoader.Size + LevelLoader.Size / 2, LevelLoader.Size, LevelLoader.Size);
Block block4 = new Block(Rect2, storage.Pull2DTexture("floor"), game, this.camera);
blocks.Add(block4);
Rect2 = new Rectangle(i * LevelLoader.Size + LevelLoader.Size / 2, (j - sizeFile[0]) * LevelLoader.Size - LevelLoader.Size / 2, LevelLoader.Size, LevelLoader.Size);
Block block2 = new Block(Rect2, storage.Pull2DTexture("floor"), game, this.camera);
blocks.Add(block2);
Rect2 = new Rectangle(i * LevelLoader.Size + LevelLoader.Size / 2, (j - sizeFile[0]) * LevelLoader.Size + LevelLoader.Size / 2, LevelLoader.Size, LevelLoader.Size);
Block block3 = new Block(Rect2, storage.Pull2DTexture("floor"), game, this.camera);
blocks.Add(block3);
}
}
}
}
}
// конец создания пола
// создание объектов на уровне
for (int i = 0; i < sizeFile[1]; i++)
{
for (int j = 0; j < sizeFile[0]; j++)
{
Rectangle Rect = new Rectangle(i * LevelLoader.Size, j * LevelLoader.Size, LevelLoader.Size, LevelLoader.Size);
if (map[i, j] == LevelObject.Empty)
{
Block block = new Block(Rect, storage.Pull2DTexture("empty"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.Wall)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_goriz"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallVertic)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_vert"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallDownRight)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_down_right"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallUpRight)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_up_right"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallLeftDown)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_left_down"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallLeftUp)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_left_up"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.Wall4Sides)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_4sides"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallURD)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_urd"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallRDL)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_rdl"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallDLU)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_dlu"), game, this.camera);
blocks.Add(block);
}
if (map[i, j] == LevelObject.WallLUR)
{
Block block = new Block(Rect, storage.Pull2DTexture("wall_lur"), game, this.camera);
blocks.Add(block);
}
//двери железные
if (levelMap[i, j] == LevelObject.DoorHoriz)
{
Door door = new Door(Rect, storage.Pull2DTexture("door_horiz"), game, this.camera, EColor.Blue, DoorOrientation.Horiz, true, i, j);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.DoorVertic)
{
Door door = new Door(Rect, storage.Pull2DTexture("door_vertic"), game, this.camera, EColor.Blue, DoorOrientation.Vert, true, i, j);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.DoorHorizOpen)
{
Door door = new Door(Rect, storage.Pull2DTexture("door_horiz_open"), game, this.camera, EColor.Blue, DoorOrientation.Horiz);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.DoorVerticOpen)
{
Door door = new Door(Rect, storage.Pull2DTexture("door_vertic_open"), game, this.camera, EColor.Blue, DoorOrientation.Vert);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Empty;
}
//двери деревянные
if (levelMap[i, j] == LevelObject.DoorWoodHoriz)
{
Door door = new Door(Rect, storage.Pull2DTexture("wood_door_horiz"), game, this.camera, EColor.Blue, DoorOrientation.HorizWood, true, i, j);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.DoorWoodVertic)
{
Door door = new Door(Rect, storage.Pull2DTexture("wood_door_vertic"), game, this.camera, EColor.Blue, DoorOrientation.VertWood, true, i, j);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.DoorWoodHorizOpen)
{
Door door = new Door(Rect, storage.Pull2DTexture("wood_door_horiz_open"), game, this.camera, EColor.Blue, DoorOrientation.HorizWood);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.DoorWoodVerticOpen)
{
Door door = new Door(Rect, storage.Pull2DTexture("wood_door_vertic_open"), game, this.camera, EColor.Blue, DoorOrientation.VertWood);
doors.Add(door);
door.posY = j;
door.posX = i;
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.Guard)
{
//пол
Block block = new Block(Rect, storage.Pull2DTexture("empty"), game, this.camera);
blocks.Add(block);
// инициализируем нового охранника
Rectangle RectGuard = new Rectangle(x + LevelLoader.SizePeople / 4, y + LevelLoader.SizePeople / 4, LevelLoader.SizePeople, LevelLoader.SizePeople);
Guards guard = new Guards(storage.Pull2DTexture("player"), storage.Pull2DTexture("player_run"), storage.Pull2DTexture("player_run_goriz"), storage.Pull2DTexture("guard_eye"), storage.Pull2DTexture("guard_eye_right"), RectGuard, game, player, this.camera, this);
guards.Add(guard);
guard.Run(PlayerMove.Left);
}
// кресла
if (levelMap[i, j] == LevelObject.Chairs_U)
{
Object obj = new Object(Rect, storage.Pull2DTexture("chairs_U"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.Chairs_R)
{
Object obj = new Object(Rect, storage.Pull2DTexture("chairs_R"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.Chairs_D)
{
Object obj = new Object(Rect, storage.Pull2DTexture("chairs_D"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.Chairs_L)
{
Object obj = new Object(Rect, storage.Pull2DTexture("chairs_L"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
// диваны
if (levelMap[i, j] == LevelObject.Sofa_U)
{
Object obj = new Object(Rect, storage.Pull2DTexture("sofa_U"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.Sofa_R)
{
Object obj = new Object(Rect, storage.Pull2DTexture("sofa_R"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.Sofa_D)
{
Object obj = new Object(Rect, storage.Pull2DTexture("sofa_D"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.Sofa_L)
{
Object obj = new Object(Rect, storage.Pull2DTexture("sofa_L"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
// ключ и пластиковая карта
if (levelMap[i, j] == LevelObject.Key)
{
Key key = new Key(Rect, storage.Pull2DTexture("key"), game, this.camera, EColor.Blue);
key.posY = j;
key.posX = i;
interactionSubjects.Add(key);
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.Card)
{
Card card = new Card(Rect, storage.Pull2DTexture("card"), game, this.camera);
card.posY = j;
card.posX = i;
interactionSubjects.Add(card);
levelMap[i, j] = LevelObject.Empty;
}
// золото
if (levelMap[i, j] == LevelObject.Gold)
{
Money money = new Money(Rect, storage.Pull2DTexture("money"), game, this.camera, 10);
interactionSubjects.Add(money);
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.Rubin)
{
Rubin rubin = new Rubin(Rect, storage.Pull2DTexture("rubin"), game, this.camera, 20);
interactionSubjects.Add(rubin);
levelMap[i, j] = LevelObject.Empty;
NumberOfJewelry++;
}
if (levelMap[i, j] == LevelObject.Brilliant)
{
Brilliant brilliant = new Brilliant(Rect, storage.Pull2DTexture("brilliant"), game, this.camera, 50);
interactionSubjects.Add(brilliant);
levelMap[i, j] = LevelObject.Empty;
NumberOfJewelry++;
}
if (levelMap[i, j] == LevelObject.Picture1)
{
Picture picture1 = new Picture(Rect, storage.Pull2DTexture("picture1"), game, this.camera, 30);
interactionSubjects.Add(picture1);
levelMap[i, j] = LevelObject.Empty;
NumberOfJewelry++;
}
if (levelMap[i, j] == LevelObject.Picture2)
{
Picture picture2 = new Picture(Rect, storage.Pull2DTexture("picture2"), game, this.camera, 30);
interactionSubjects.Add(picture2);
levelMap[i, j] = LevelObject.Empty;
NumberOfJewelry++;
}
if (levelMap[i, j] == LevelObject.Picture3)
{
Picture picture3 = new Picture(Rect, storage.Pull2DTexture("picture3"), game, this.camera, 30);
interactionSubjects.Add(picture3);
levelMap[i, j] = LevelObject.Empty;
NumberOfJewelry++;
}
// стол системы управления камерами
if (levelMap[i, j] == LevelObject.SpLU)
{
SysControl sysControl = new SysControl(Rect, storage.Pull2DTexture("spLU"), game, this.camera);
sysControls.Add(sysControl);
sysControl.posY = j;
sysControl.posX = i;
sysControl.generateMathEmample();
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.SpUR)
{
SysControl sysControl = new SysControl(Rect, storage.Pull2DTexture("spUR"), game, this.camera);
sysControls.Add(sysControl);
sysControl.posY = j;
sysControl.posX = i;
sysControl.generateMathEmample();
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.SpRD)
{
SysControl sysControl = new SysControl(Rect, storage.Pull2DTexture("spRD"), game, this.camera);
sysControls.Add(sysControl);
sysControl.posY = j;
sysControl.posX = i;
sysControl.generateMathEmample();
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.SpDL)
{
SysControl sysControl = new SysControl(Rect, storage.Pull2DTexture("spDL"), game, this.camera);
sysControls.Add(sysControl);
sysControl.posY = j;
sysControl.posX = i;
sysControl.generateMathEmample();
levelMap[i, j] = LevelObject.Wall;
}
// стол с компьютером
if (levelMap[i, j] == LevelObject.TableU)
{
Object obj = new Object(Rect, storage.Pull2DTexture("tableU"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.TableR)
{
Object obj = new Object(Rect, storage.Pull2DTexture("tableR"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.TableD)
{
Object obj = new Object(Rect, storage.Pull2DTexture("tableD"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.TableL)
{
Object obj = new Object(Rect, storage.Pull2DTexture("tableL"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
// куст
if (levelMap[i, j] == LevelObject.Plant)
{
Object obj = new Object(Rect, storage.Pull2DTexture("plant"), game, this.camera);
objs.Add(obj);
levelMap[i, j] = LevelObject.Wall;
}
if (levelMap[i, j] == LevelObject.CameraUL)
{
Rectangle Rect2 = new Rectangle(i * LevelLoader.Size - size / 3, j * LevelLoader.Size - size / 3, Convert.ToInt32(size * 2.25), Convert.ToInt32(size * 2.25));
Cameras newCamera = new Cameras(Rect2, storage.Pull2DTexture("camera_UL_active"), storage.Pull2DTexture("camera_UL"), LevelObject.CameraUL, game, this.camera);
cameras.Add(newCamera);
newCamera.posY = j;
newCamera.posX = i;
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.CameraUR)
{
Rectangle Rect2 = new Rectangle(i * LevelLoader.Size - size / 3 * 2, j * LevelLoader.Size - size / 3, Convert.ToInt32(size * 2.25), Convert.ToInt32(size * 2.25));
Cameras newCamera = new Cameras(Rect2, storage.Pull2DTexture("camera_UR_active"), storage.Pull2DTexture("camera_UR"), LevelObject.CameraUR, game, this.camera);
newCamera.posY = j;
newCamera.posX = i;
cameras.Add(newCamera);
levelMap[i, j] = LevelObject.Empty;
}
// лазеры
if (levelMap[i, j] == LevelObject.LaserHoriz)
{
int size2 = (int)(size * 1.5);
Rectangle Rect2 = new Rectangle(i * LevelLoader.Size - size / 4, j * LevelLoader.Size, size2, size);
Laser laser = new Laser(Rect2, storage.Pull2DTexture("laser2_horiz"), storage.Pull2DTexture("laser2_horiz_inactive"), LevelObject.LaserHoriz, game, this.camera);
laser.typeLaser = LevelObject.LaserHoriz;
lasers.Add(laser);
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.LaserVertic)
{
int size2 = (int)(size * 1.5);
Rectangle Rect2 = new Rectangle(i * LevelLoader.Size, j * LevelLoader.Size - size / 4, size, size2);
Laser laser = new Laser(Rect2, storage.Pull2DTexture("laser2_vert"), storage.Pull2DTexture("laser2_vert_inactive"), LevelObject.LaserVertic, game, this.camera);
laser.typeLaser = LevelObject.LaserVertic;
lasers.Add(laser);
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.LaserHorizMoving)
{
int size2 = (int)(size * 1.5);
Rectangle Rect2 = new Rectangle(i * LevelLoader.Size - size / 4, j * LevelLoader.Size, size2, size);
Laser laser = new Laser(Rect2, storage.Pull2DTexture("laser2_horiz"), storage.Pull2DTexture("laser2_horiz_inactive"), LevelObject.LaserHorizMoving, game, this.camera);
laser.typeLaser = LevelObject.LaserHorizMoving;
lasers.Add(laser);
levelMap[i, j] = LevelObject.Empty;
}
if (levelMap[i, j] == LevelObject.LaserVerticMoving)
{
int size2 = (int)(size * 1.5);
Rectangle Rect2 = new Rectangle(i * LevelLoader.Size, j * LevelLoader.Size - size / 4, size, size2);
Laser laser = new Laser(Rect2, storage.Pull2DTexture("laser2_vert"), storage.Pull2DTexture("laser2_vert_inactive"), LevelObject.LaserVerticMoving, game, this.camera);
laser.typeLaser = LevelObject.LaserVerticMoving;
lasers.Add(laser);
levelMap[i, j] = LevelObject.Empty;
}
y += LevelLoader.Size;
}
y = 0;
x += LevelLoader.Size;
}
// конец создание объектов на уровне
lenghtX = LevelLoader.Size * sizeFile[1]; // длина уровня в пикселях
lenghtY = LevelLoader.Size * sizeFile[0];
//считывание пути траекторий и связки
lines = File.ReadAllLines(lvl_name); //получили массив строк
//считываем размеры массива с уровнем (sizeFile[0] значение - строки, sizeFile[1] - колонки)
for (int i = sizeFile[0]; i < lines.Length; i++)
{
int step = 0;
int numberGuard = 0;
int nextX = 0;
int nextY = 0;
str = lines[i].Split(' ');
LevelObject obj = (LevelObject)Int32.Parse(str[0]);
// считываем траектории охранников
// тип связки (Охранник Номер Шаг СледУ СледХ)
if (obj == LevelObject.Guard)
{
step = Convert.ToInt32(str[2]);
numberGuard = Convert.ToInt32(str[1]);
nextX = Convert.ToInt32(str[4]);
nextY = Convert.ToInt32(str[3]);
// добавляем новую строку под координату
guards[numberGuard].wayToPatrol.Add(new List<int>());
//задание начальной точки следования для охранника
if (step == 0)
{
guards[numberGuard].TargetX = nextX;
guards[numberGuard].TargetY = nextY;
}
// задание точки патрилрования
guards[numberGuard].wayToPatrol[step].Add(nextX);
guards[numberGuard].wayToPatrol[step].Add(nextY);
//максимальное кол-во шагов.
guards[numberGuard].MaxStepToPatrol++;
}
// считываем траектории лазеров
// тип связки (Лазер Номер Шаг СледУ СледХ)
if (obj == LevelObject.LaserVerticMoving)
{
step = Convert.ToInt32(str[2]);
numberGuard = Convert.ToInt32(str[1]);
nextX = Convert.ToInt32(str[4]);
nextY = Convert.ToInt32(str[3]);
// добавляем новую строку под координату
lasers[numberGuard].wayToPatrol.Add(new List<int>());
//задание начальной точки следования для охранника
if (step == 0)
{
lasers[numberGuard].TargetX = nextX;
lasers[numberGuard].TargetY = nextY;
}
// задание точки патрилрования
lasers[numberGuard].wayToPatrol[step].Add(nextX);
lasers[numberGuard].wayToPatrol[step].Add(nextY);
//максимальное кол-во шагов.
lasers[numberGuard].MaxStepToPatrol++;
lasers[numberGuard].Patrol(); // сразу задаем первую точку, куда двигаться лазеру
}
// считываем связки (пункт управления - камера)
// связка (ПунктУправления КоордХПункта КоордУПунта КоордХКамеры КоордУКамеры)
if (obj == LevelObject.SpDL || obj == LevelObject.SpLU || obj == LevelObject.SpRD || obj == LevelObject.SpUR)
{
int posX = Convert.ToInt32(str[1]);
int posY = Convert.ToInt32(str[2]);
int posXCam = Convert.ToInt32(str[3]);
int posYCam = Convert.ToInt32(str[4]);
foreach (SysControl sysControl in sysControls)
{
if (sysControl.posX == posX && sysControl.posY == posY)
{
sysControl.targetCameraX = posXCam;
sysControl.targetCameraY = posYCam;
}
}
}
// считываем связки (ключ - дверь)
// связка (КлючИлиКарта КоордХКлюча КоордУКлюча КоордХДвери КоордУДвери)
if (obj == LevelObject.Key || obj == LevelObject.Card)
{
int posX = Convert.ToInt32(str[1]);
int posY = Convert.ToInt32(str[2]);
int posXDoor = Convert.ToInt32(str[3]);
int posYDoor = Convert.ToInt32(str[4]);
foreach (BaseObject interactionSubject in interactionSubjects)
{
if (interactionSubject.posX == posX && interactionSubject.posY == posY)
{
interactionSubject.targetDoorX = posXDoor;
interactionSubject.targetDoorY = posYDoor;
}
}
}
}
Guards.SetLevelMap(levelMap, lenghtX / LevelLoader.Size, lenghtY / LevelLoader.Size);
}
}
public BacklogItemBuilder WithEstimatedComplexity(Complexity complexity)
{
_complexity = complexity;
return this;
}
public PluginAttribute(string name, Complexity complexity)
{
_name = name;
_complexity = complexity;
}
