private float timer; // время до следующего отключения, вкл. лазера
#endregion Fields
#region Constructors
/// <summary>
/// Конструктор лазера
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <param name="texture">Текстура лазера</param>
/// <param name="textureInactive">Текстура выключенного лазера</param>
/// <param name="typeLaser">Тип лазера</param>
/// <param name="game">ссылка на игру</param>
/// <param name="camera">ссылка на камеру</param>
public Laser(Rectangle rect, Texture2D texture, Texture2D textureInactive, LevelObject typeLaser, Game1 game, Camera camera)
: base(rect, texture, game, camera)
{
timer = intervalActivity;
intervalActivity += 0.3f;
if (intervalActivity >= 3.2f)
{
intervalActivity = 2.0f;
}
this.Rect = rect;
this.textureInactive = textureInactive;
this.typeLaser = typeLaser;
this.speed = 1;
//массив для патрулирования
// временный. Потом будет считываться из файла
/*wayToPatrol.Add(new List<int>());// добавляем новую строку под координату
wayToPatrol[0].Add(8); // первым указывается координата X
wayToPatrol[0].Add(5); // второе - координата Y
wayToPatrol.Add(new List<int>());// добавляем новую строку под координату
wayToPatrol[1].Add(11);
wayToPatrol[1].Add(8);
*/
//проверяем на тип лазера. Будет ли он двигаться или нет.
if (this.typeLaser == LevelObject.LaserHorizMoving || this.typeLaser == LevelObject.LaserVerticMoving)
{
this.currentStepPatrol = 0;
}
}
public bool AddTaskNode(HierarchyObject taskRelations, TaskObject taskToAdd, LevelObject levelToAddTo)
{
bool added = false;
if (_allLevels.Count > 0)
{
foreach (LevelObject item in _allLevels)
{
if (item.UniqueId.Equals(levelToAddTo.UniqueId))
{
bool valid = true;
foreach (HierarchyTaskObject items in item.LevelCollection)
{
if (taskRelations.UniqueId == items.hierarchyObj.UniqueId
&& taskToAdd.UniqueId == items.taskObj.UniqueId)
{
valid = false;
}
}
if(valid == true)
{
HierarchyTaskObject TO = new HierarchyTaskObject(Guid.NewGuid().ToString(), taskRelations.Name+taskToAdd.Name);
TO.hierarchyObj = taskRelations;
TO.taskObj = taskToAdd;
AddToLevel(levelToAddTo, TO);
added = true;
break;
}
}
}
}
return added;
}
public CameraControllerPerson(Camera cam, LevelObject character, Vector3 offset)
: base(cam, character.transform.Translation + offset, character.transform.Translation)
{
_offset = offset;
_character = character;
_camera_sence = (float)Config.Instance["_player_camera_sence"];
}
public override void LocateToLevel(LevelObject __parent)
{
#if DEBUG
if (__parent != null)
ExcLog.LogException("GameCharacter.LocateToLevel with parent not null!");
#endif
_hisLevel.AddEngineObject(_levelObject);
_onLevel = true;
}
public GameCharacter(string __aliveName, Matrix __aliveMatrix, GameLevel __level)
: base(__level, true, true)
{
_levelObject = Engine.GameEngine.LoadObject(__aliveName, __aliveMatrix, true, true) as LevelObject;
_levelObject.matrialType = PivotObjectMaterialType.DynamicHuman;
_controllerAlive = (_levelObject.renderaspect as Engine.Render.AnimRenderObject).character;
_isAlive = false;
_onLevel = false;
}
public void LocateBillboardToLevel(LevelObject __parentObject)
{
if (!_onLevel)
{
_onLevel = true;
_hisLevel.AddEngineObject(_object, __parentObject);
_object.CreateRenderBillboard();
_locatedAtLastFrame = true;
}
}
public void LocateConstrainedToLevel(LevelObject __parentObject, Vector3 __delta)
{
if (!_onLevel)
{
_onLevel = true;
_object.CreateRenderConstrBillboard();
CalcParameters(__parentObject);
_hisLevel.AddEngineObject(_object, Matrix.CreateTranslation(__delta), __parentObject);
_locatedAtLastFrame = true;
}
}
private void TryAddLevelObject(List <LevelObject> levelObjects, Transform transform)
{
string prefabPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(transform.gameObject);
if (prefabPath == null || !this.TryGetSerializableAssetPath(prefabPath, out string resourcesPath))
{
return;
}
var levelObject = new LevelObject()
{
PrefabPath = resourcesPath,
Position = (LevelPosition)transform.position
};
levelObjects.Add(levelObject);
}
private void LevelObjectSelector_Load(object sender, EventArgs e)
{
treeView1.Nodes.Add((TreeNode)MainForm.Default.treeView1.Nodes[0].Clone());
treeView1.Nodes[0].Expand();
if (levelObject != null)
{
TreeNode[] nodes = treeView1.Nodes.Find(levelObject.name, true);
if (nodes.Length > 0)
{
treeView1.SelectedNode = nodes[0];
}
else
{
levelObject = null;
}
}
}
private void SpawnUpsideDown(LevelObject l)
{
if (_upsidedownlevelindex >= l.GetLevel().Count)
{
_upsidedownlevelindex = 0;
_down = _levelbook.BuildRandomLevel(30, 5);
builddown();
}
foreach (float f in l.GetLevel()[_upsidedownlevelindex])
{
var obstacle = f == 0f ? Instantiate(FloorObstaclePrefab, new Vector3(12, f, 0), Quaternion.identity)
: Instantiate(ObstaclePrefab, new Vector3(12, -f, 0), Quaternion.identity);
obstacle.GetComponent <ObstacleHandler>().Spawn = this;
LiveObstacles.Add(obstacle);
}
_upsidedownlevelindex++;
}
public void CreateLevelSelect()
{
List <LevelObject> _levels = levelSystem.GetAllLevels();
for (int i = 0; _levels.Count > 0; i++)
{
int levelsOnNextBlock = Mathf.Min(_levels.Count, 8);
LevelObject[] objects = new LevelObject[levelsOnNextBlock];
for (int j = 0; j < levelsOnNextBlock; j++)
{
objects[j] = _levels[j];
}
_levels.RemoveRange(0, levelsOnNextBlock);
CreateButtonGroup(objects, i * xOffset);
}
}
private void CreateSlideBlock()
{
saveButton.interactable = false;
LevelObject levelObject = LevelObjectAtPosition(startIndex);
LevelFeature levelFeature = GetLevelFeature(LevelFeature.features.SlideBlock);
if (levelObject == null)
{
levelObject = new LevelObject();
levelObject.gameObject = Instantiate(slideBlockPrefab, new Vector2(startIndex * spacingBetweenSamples + levelFeature.offset, levelTransform.position.y), Quaternion.identity, levelTransform);
levelObject.feature = levelFeature;
levelObject.songPositionIndex = startIndex;
levelObjects.Add(levelObject);
}
}
private void CustomGLControl_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
rMouse = e.Button == MouseButtons.Right;
lMouse = e.Button == MouseButtons.Left;
if (e.Button == MouseButtons.Left && level != null)
{
LevelObject obj = GetObjectAtScreenPosition(e.Location.X, e.Location.Y, out bool cancelSelection);
if (cancelSelection)
{
return;
}
SelectObject(obj);
}
}
private void PopulateInitialEntities()
{
if (levelInfo == null)
{
return;
}
for (int i = 0; i < levelInfo.StartObjects.Length; i++)
{
LevelObject lo = levelInfo.StartObjects[i];
BasePlayer newOwner = getPlayer(lo.Player);
if (CreateEntity(lo.X, lo.Y, lo.Type, newOwner) == false)
{
Log.Write(LogType.Generic, LogSeverity.Status, "Failed to place entity of type '" + lo.Type + "' at " + lo.X + "," + lo.Y + ".");
}
}
}
public override void Update(GameTime gameTime, InputState input)
{
if (ItemLocations == null)
{
return;
}
LevelObject.Update(Level, this, ItemLocations, IsRoomChanged(), seedOptions, Settings, ScreenManager);
FamiliarManager.Update(Level);
deathLinkService?.Update(Level, ScreenManager);
#if DEBUG
TimespinnerAfterDark(input);
#endif
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(gameObject);
SceneManager.sceneLoaded += OnSceneLoaded;
LoadAllLevels();
_activeLevel = _levels.Find(l => l.SceneName == SceneManager.GetActiveScene().name);
}
else
{
Destroy(gameObject);
}
}
private void Spawn(LevelObject l)
{
if (_levelindex >= l.GetLevel().Count)
{
Tutorial = false;
_levelindex = 0;
buildup();
}
foreach (float f in l.GetLevel()[_levelindex])
{
var obstacle = f == 0f ? Instantiate(FloorObstaclePrefab, new Vector3(12, f, 0), Quaternion.identity)
: Instantiate(ObstaclePrefab, new Vector3(12, f, 0), Quaternion.identity);
obstacle.GetComponent <ObstacleHandler>().Spawn = this;
LiveObstacles.Add(obstacle);
}
_levelindex++;
}
public void CountLevelObjects()
{
ResetObjectCounts();
Transform levelObjectParent = transform.Find("ObjectSpawnLocation");
foreach (Transform child in levelObjectParent)
{
if (child.gameObject.tag == "LevelObject")
{
LevelObject childObject = child.gameObject.GetComponent <LevelObject>();
switch (childObject.colourName)
{
case "red": _numRedObjects++;
break;
case "blue": _numBlueObjects++;
break;
case "yellow": _numYellowObjects++;
break;
case "green": _numGreenObjects++;
break;
default: Debug.Log($"Level object with no colour name set: {child.gameObject.name}");
break;
}
switch (childObject.shapeName)
{
case "square": _numSquares++;
break;
case "triangle": _numTriangles++;
break;
case "circle": _numCircles++;
break;
default: Debug.Log($"Level object with no shape name set: {child.gameObject.name}");
break;
}
}
}
}
private void LoadPatients(LevelObject _level)
{
_patientOptions.Clear();
_patientOptions.Add("-- Select Patient --");
List <PatientFile> _rawPatientFiles = Resources.LoadAll <PatientFile>("Patient Files").ToList();
foreach (PatientFile _patientFile in _level.PatientFiles)
{
_rawPatientFiles.Remove(_patientFile);
}
foreach (PatientFile _patientFile in _rawPatientFiles)
{
_patientOptions.Add(_patientFile.PatientName);
}
_patientFiles = _rawPatientFiles.ToArray();
}
public override void Transform(LevelObject obj, Vector3 vec, Vector3 pivot)
{
var mat = obj.modelMatrix;
if (toolbox.transformSpace == TransformSpace.Global)
{
var trans = Matrix4.CreateTranslation(vec);
mat = mat * trans;
}
else if (toolbox.transformSpace == TransformSpace.Local)
{
// Compensate for scale diminishing the strength of the translation
var trans = Matrix4.CreateTranslation(vec / obj.scale.LengthFast);
mat = trans * mat;
}
obj.SetFromMatrix(mat);
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
if (e.Node.Tag is Level)
{
Editor.Default.selectLevel();
}
if (e.Node.Tag is Layer)
{
Layer l = (Layer)e.Node.Tag;
Editor.Default.selectLayer(l);
}
if (e.Node.Tag is LevelObject)
{
LevelObject lo = (LevelObject)e.Node.Tag;
Editor.Default.selectLevelObject(lo);
Camera.Position = lo.position;
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is Area)
{
Area area = value as Area;
string description = string.Format("{0}: ({1}, {2})-({3}, {4})", area.ObjectType,
area.X, area.Y, area.X + area.Width, area.Y + area.Height);
return(description);
}
else if (value is LevelObject)
{
LevelObject levelObject = value as LevelObject;
string description = string.Format("{0}: ({1}, {2})", levelObject.ObjectType, levelObject.X, levelObject.Y);
return(description);
}
return("Unknown object");
}
public LevelObject GetLevelObject(string n)
{
for (int i = 0; i < tabNumber.Length; i++)
{
for (int j = 0; j < tabNumber[i].tabItem.Length; j++)
{
if (tabNumber[i].tabItem[j].objectPrefab.name == n)
{
LevelObject obj = new LevelObject();
obj.LObject = tabNumber[i].tabItem[j].objectPrefab;
obj.LObjectType = (int)tabNumber[i].tabItem[j].objectType;
obj.bundleName = tabNumber[i].tabItem[j].objectBundleName;
return(obj);
}
}
}
return(null);
}
private Tile GetTileObjectAtDirection(TileSide tileSideDirection)
{
Vector2 directionOffset = _tileSideDictionary[tileSideDirection];
Vector3 _currentPosition = transform.parent.position;
Vector3 topPosition = new Vector3(_currentPosition.x + directionOffset.x
, _currentPosition.y + directionOffset.y
, _currentPosition.z);
LevelObject levelObject = Registry.map.GetLevelObjectAtPosition(topPosition);
if (levelObject is Tile && !(levelObject is HazardTile))
{
return((Tile)levelObject);
}
else
{
return(null);
}
}
protected void HandleSpriteFlipping()
{
Vector3 topPosition = transform.position + Vector3.up;
Vector3 bottomPosition = transform.position + Vector3.down;
LevelObject levelObjectAtTop = Registry.map.GetLevelObjectAtPosition(topPosition);
LevelObject levelObjectAtBottom = Registry.map.GetLevelObjectAtPosition(bottomPosition);
SpriteFlipper spriteFlipper = gameObject.GetComponentInChildren <SpriteFlipper>();
if (levelObjectAtBottom == null && levelObjectAtTop != null && levelObjectAtTop is Tile)
{
spriteFlipper.SetFlippedY(true);
Debug.Log("FLIPPING");
}
else
{
Debug.Log("DID NOT FLIP");
}
}
void Update()
{
foreach (Checkline checkline in checklines)
{
if (null == checkline || !checkline.enabled)
{
continue;
}
LevelObject chkLineObj = checkline.GetComponent <LevelObject>();
SBSVector3 linePos = chkLineObj.LocalToWorld.position;
LevelObject[] gameObjects = LevelRoot.Instance.Query(chkLineObj.Bounds, checkline.layersMask);
foreach (LevelObject levelObj in gameObjects)
{
if (!levelObj.IsMovable)
{
continue;
}
SBSVector3 levelObjPos = levelObj.LocalToWorld.position;
SBSPlane linePlane = new SBSPlane(chkLineObj.LocalToWorld.MultiplyVector(checkline.perpendicularAxis), linePos);
float d0 = linePlane.GetDistanceToPoint(((MovableLevelObject)levelObj).PrevLocalToWorld.position);
float d1 = linePlane.GetDistanceToPoint(levelObjPos);
bool front = d0 < 0.0f && d1 >= 0.0f,
back = d0 >= 0.0f && d1 < 0.0f;
if (front || back)
{
SBSVector3 n = chkLineObj.LocalToWorld.MultiplyVector(checkline.parallelAxis);
SBSPlane p0 = new SBSPlane(n, linePos - n * (checkline.width * 0.5f)),
p1 = new SBSPlane(-n, linePos + n * (checkline.width * 0.5f));
if (p0.GetDistanceToPoint(levelObjPos) >= 0.0f && p1.GetDistanceToPoint(levelObjPos) >= 0.0f)
{
Debug.Log(levelObj.name + " has passed checkline " + checkline.name);
levelObj.SendMessage("OnCheckline", new Message(checkline, front), SendMessageOptions.DontRequireReceiver);
}
}
}
}
}
public void Load(LevelObject levelObject)
{
this.levelObject = levelObject;
LevelIcon.sprite = levelObject.Ico;
MapName.text = levelObject.LevelInfo.LevelName;
RecomendedLevel.text = levelObject.LevelInfo.RecomendedLevel;
Description.text = levelObject.LevelInfo.LevelDiscription;
List <unitCategory> unitsCategory = new List <unitCategory>();
foreach (UnitObject unit in levelObject.Units)
{
bool haveCategory = false;
foreach (unitCategory ct in unitsCategory)
{
if (unit == ct.unitImage)
{
haveCategory = true;
ct.number++;
}
}
if (!haveCategory)
{
unitsCategory.Add(new unitCategory(unit));
}
}
if (UnitParent.childCount > 0)
{
for (int i = 0; i < UnitParent.childCount; i++)
{
Destroy(UnitParent.GetChild(i).gameObject);
}
}
foreach (unitCategory uc in unitsCategory)
{
UnitInfo unitInfo = Instantiate <UnitInfo>(UnitPrefab, UnitParent);
unitInfo.Load(uc.unitImage, uc.number);
unitInfo.GetComponent <Button>().onClick.AddListener(() => LoadUnitInfo(uc.unitImage));
unitInfo.GetComponent <Button>().onClick.AddListener(() => OnClickAction.Invoke());
}
}
public void NewLevel()
{
doorOpened = false;
if (levelsCompleted > 0)
{
if (currentLevelIndex < levelList.Count)
{
if (level != null)
{
Destroy(level);
}
activeLevel = levelList[currentLevelIndex];
level = Instantiate(activeLevel.levelPrefab, Vector3.zero, Quaternion.identity);
currentLevelIndex++;
//currentLevelIndex = Random.Range(0, levelList.Count);
//get enemies
enemyAi = EnemyAi.instances;
totalKills += currentKills;
currentKills = 0;
}
else
{
if (level != null)
{
Destroy(level);
}
activeLevel = winnerLevel;
activeLevel.levelPrefab.SetActive(true);
level = activeLevel.levelPrefab;
}
player.ResetPosition(activeLevel.spawnPoint);
player.GetComponent <ShootingController>().ResetAmmo();
}
else
{
level = activeLevel.levelPrefab;
}
cameraOrigin = maincam.transform.position;
UpdateKillsRemaining();
}
// Update is called once per frame
void Update()
{
if (level == null && FindObjectOfType <LevelObject>())
{
level = FindObjectOfType <LevelObject>();
}
if (level != null)
{
if (level.maxGems > 0)
{
textcomp.text = level.collectedGems + " / " + level.maxGems;
bg.color = Color.white;
}
else
{
Blank();
}
}
}
private void AbsorbObject(GameObject objectToAbsorb)
{
LevelObject absorbedObject = objectToAbsorb.GetComponent <LevelObject>();
//Disable collision on the object so we can pull it through the front wall
absorbedObject.SetCollision(false);
//Pull the object towards us, shrink it and put it in the display container
StartCoroutine(PullObject(objectToAbsorb, muzzlePosition.position, new Vector3(0.02f, 0.02f, 0.02f), 3f));
//Tell the object to animate
absorbedObject.enableRotation = true;
//Destroy an existing object if we have one
DestroyExistingWeaponObject();
//Set the absorbed object as our one for firing.
SetWeaponObjectProperties(objectToAbsorb);
}
private LevelObject Levels(Rect position, LevelObject itemValue)
{
// Text fields do not like null values!
if (itemValue == null)
itemValue = new LevelObject();
position.width -= 50;
//EditorGUI.TextField(position, itemValue.name);
itemValue = (LevelObject)EditorGUI.ObjectField(position, itemValue.name, itemValue, typeof(LevelObject), true);
position.x = position.xMax + 5;
position.width = 45;
/*if (GUI.Button(position, "Info"))
{
}*/
return itemValue;
}
private void PickRandomComplexBlock(LevelObject l)
{
int rand = Random.Range(0, 2);
switch (rand)
{
case 0:
l.AddTightSqueeze();
break;
case 1:
l.AddHighJump();
break;
case 2:
l.AddHighTightSqueeze();
break;
}
}
// fire a raycast at the given worldposition and get the levelobject at that postion
private LevelObject GetLevelObjectAt(Vector3 position)
{
LevelObject levelObject = null;
RaycastHit2D[] hits = Physics2D.RaycastAll(position, Vector2.zero);
Debug.DrawRay(position, Vector3.forward * 200, Color.green, 20F, false);
foreach (RaycastHit2D hit in hits)
{
if (hit.collider != null)
{
if (hit.transform.gameObject.layer == LayerMask.NameToLayer("EditorSelectionColliders"))
{
levelObject = hit.transform.parent.gameObject.GetComponent<LevelObject>();
}
}
}
return levelObject;
}
//Check for additional colors, call the update on the level automatically
void UpdateScriptableObjectFromTexture(Texture2D texture)
{
EditorApplication.delayCall += () =>
{
LevelObject level = AssetDatabase.LoadAssetAtPath <LevelObject>(LevelPath);
texture = AssetDatabase.LoadAssetAtPath <Texture2D>(assetPath);
List <ColorToPrefab> prefabs = new List <ColorToPrefab>(level.prefabs);
bool newColor = false;
//Check for new colors
for (int x = 0; x < texture.width; x++)
{
for (int y = 0; y < texture.height; y++)
{
Color color = texture.GetPixel(x, y);
if (color.a < 1)
{
continue;
}
//Check to see if the current color is not in the list, if not add it
if (!prefabs.Any(cp => cp.color == color))
{
newColor = true;
prefabs.Add(new ColorToPrefab()
{
color = color
});
}
}
}
//Assign new colors
if (newColor)
{
level.prefabs = prefabs.ToArray();
}
//update the level
level.UpdateLevel();
};
}
static void InstantiateLevelObjectPrefabInCell(GridLayout grid, GameObject brushTarget, Vector3Int position,
GameObject prefab, Action clearTile)
{
var instance = Instantiate(prefab);
if (instance != null)
{
LevelObject levelObject = instance.GetComponent <LevelObject>();
if (levelObject == null)
{
levelObject = instance.AddComponent <LevelObject>();
}
levelObject.DestroyTile = clearTile;
instance.transform.SetParent(brushTarget.transform);
instance.transform.position =
grid.LocalToWorld(grid.CellToLocalInterpolated(position + new Vector3(0.5f, 0.55f, 0.5f)));
}
}
private void button1_Click(object sender, EventArgs e)
{
// here we have to get the object's id from the textbox as a hex string
// then we convert it to ushort (uint16) and then use that
string value = textBox1.Text;
ushort objectID = Convert.ToUInt16(value, 16);
LevelObject trackObj = new LevelObject();
trackObj.objID = objectID;
trackObj.routeID = -1;
MiscHacks misc = new MiscHacks();
trackObj.modelName = misc.returnModel(objectID);
trackObj.friendlyName = misc.returnName(objectID);
if (trackObj.modelName != "null")
{
FileBase objFB = new FileBase();
if (File.Exists(Properties.Settings.Default.curDir + "/objects/" + trackObj.modelName + ".bmd"))
{
objFB.Stream = new FileStream(Properties.Settings.Default.curDir + "/objects/" + trackObj.modelName + ".bmd", FileMode.Open);
rofl.Items.Add(trackObj);
rofl.Refresh();
Close();
}
else
{
MessageBox.Show("File /objects/" + trackObj.modelName + ".bmd does not exist. Please add this file and it's depencies before you can add this object.");
Close();
return;
}
}
else
{
rofl.Items.Add(trackObj);
rofl.Refresh();
Close();
}
}
// add an object to the level. this step of reference is needed for later deconstruction of the level and serialization
public void DeleteObject(LevelObject levelObj)
{
if (LevelPlacer._instance != null)
{
switch (levelObj.objectType)
{
case LevelObject.ObjectType.turret:
turrets.Remove((Turret)levelObj);
break;
case LevelObject.ObjectType.attractor:
attractors.Remove((Attractor)levelObj);
break;
case LevelObject.ObjectType.portal:
portals.Remove((Portal)levelObj);
levelObj.GetComponent <Portal>().Unlink();
break;
case LevelObject.ObjectType.speedStrip:
speedStrips.Remove((SpeedStrip)levelObj);
break;
case LevelObject.ObjectType.bouncer:
bouncers.Remove((Bouncer)levelObj);
break;
default:
//Debug.Log("Wasnt able to add the levelobject to the LevelDataMono of type " + lo.objectType);
break;
}
//ProgressManager.GetProgress().unlocks.inventory.Add(levelObj.objectType, 1);
DestroyImmediate(levelObj.gameObject);
UndoManager.AddUndoPoint();
}
else
{
Debug.LogError("LevelPlacer needed to add an object to the level.");
}
}
private void Awake()
{
Ship[] sceneShips = GameObject.FindObjectsOfType <Ship>();
List <Ship> assetShips = Resources.LoadAll <Ship>("Prefabs/").ToList();
foreach (var s in sceneShips)
{
try
{
LevelObject newLevelObject = new LevelObject();
newLevelObject.prefab = assetShips.Find(x => x.Name == s.Name).gameObject;
newLevelObject.position = s.transform.position;
newLevelObject.rotation = s.transform.rotation;
levelObjects.Add(newLevelObject);
}
catch (Exception e)
{
Debug.LogError(e);
}
}
}
public override void LocateToLevel(LevelObject __parentObject)
{
if (!_onLevel)
{
_onLevel = true;
_hisLevel.AddEngineObject(_object, __parentObject);
_object.CreateRenderSimple();
_locatedAtLastFrame = true;
}
}
/// <summary>
/// Фунция возвращает тип стены.
/// Анализирует соседние клетки и делает вывод.
/// </summary>
/// <param name="array">Весь массив уровня</param>
/// <param name="i">Текущая строка</param>
/// <param name="j">Текущая колонка</param>
/// <param name="iEnd">Максимальная строка</param>
/// <param name="jEnd">Максимальная колонка</param>
/// <returns>Тип стены в веди int</returns>
LevelObject isWallType(LevelObject[,] array, int i, int j, int iEnd, int jEnd)
{
// проверка краевых точек массива
/*
* *----
* -----
* -----
* -----
*/
if (i == 0 && j == 0)
{
return LevelObject.WallDownRight;
}
/*
* -----
* -----
* -----
* *----
*/
if (i == 0 && j == jEnd)
{
return LevelObject.WallUpRight;
}
/*
* ----*
* -----
* -----
* -----
*/
if (i == iEnd && j == 0)
{
return LevelObject.WallLeftDown;
}
/*
* -----
* -----
* -----
* ----*
*/
if (i == iEnd && j == jEnd)
{
return LevelObject.WallLeftUp;
}
// проверяем крайнии линии (краевые точки уже проверили и сделали return)
/*
* -----
* *----
* *----
* -----
*/
if (i == 0) {
// *
// **
// *
if (isWall(array[i, j - 1]) && isWall(array[i, j + 1]) && isWall(array[i + 1, j]))
{
return LevelObject.WallURD;
}
// *
// *
if (isWall(array[i, j - 1]) && isWall(array[i, j + 1]))
{
return LevelObject.WallVertic;
}
// **
// *
if (isWall(array[i, j + 1]) && isWall(array[i + 1, j]))
{
return LevelObject.WallDownRight;
}
// *
// **
if (isWall(array[i + 1, j]) && isWall(array[i, j - 1]))
{
return LevelObject.WallUpRight;
}
}
/*
* -----
* ----*
* ----*
* -----
*/
if (i == iEnd)
{
// *
// **
// *
if (isWall(array[i - 1, j]) && isWall(array[i, j - 1]) && isWall(array[i, j + 1]))
{
return LevelObject.WallDLU;
}
// *
// *
if (isWall(array[i, j - 1]) && isWall(array[i, j + 1]))
{
return LevelObject.WallVertic;
}
// **
// *
if (isWall(array[i, j + 1]) && isWall(array[i - 1, j]))
{
return LevelObject.WallLeftDown;
}
// *
// **
if (isWall(array[i - 1, j]) && isWall(array[i, j - 1]))
{
return LevelObject.WallLeftUp;
}
}
/*
* -----
* *----
* *----
* -----
*/
if (j == 0)
{
// ***
// *
if (isWall(array[i, j + 1]) && isWall(array[i - 1, j]) && isWall(array[i + 1, j]))
{
return LevelObject.WallRDL;
}
// **
if (isWall(array[i - 1, j]) && isWall(array[i + 1, j]))
{
return LevelObject.Wall;
}
// **
// *
if (isWall(array[i + 1, j]) && isWall(array[i, j + 1]))
{
return LevelObject.WallDownRight;
}
// **
// *
if (isWall(array[i - 1, j]) && isWall(array[i, j + 1]))
{
return LevelObject.WallLeftDown;
}
}
/*
* -----
* ----*
* ----*
* -----
*/
if (j == jEnd)
{
// *
// ***
if (isWall(array[i, j - 1]) && isWall(array[i - 1, j]) && isWall(array[i + 1, j]))
{
return LevelObject.WallLUR;
}
// **
if (isWall(array[i - 1, j]) && isWall(array[i + 1, j]))
{
return LevelObject.Wall;
}
// *
// **
if (isWall(array[i, j - 1]) && isWall(array[i - 1, j]))
{
return LevelObject.WallLeftUp;
}
// *
// **
if (isWall(array[i + 1, j]) && isWall(array[i, j - 1]))
{
return LevelObject.WallUpRight;
}
}
// проверяем центральную часть уровня
/*
* -----
* -***-
* -***-
* -----
*/
// *
// ***
// *
if (isWall(array[i - 1, j]) && isWall(array[i + 1, j]) && isWall(array[i, j - 1]) && isWall(array[i, j + 1]))
{
return LevelObject.Wall4Sides;
}
// *
// **
// *
if (isWall(array[i, j - 1]) && isWall(array[i, j + 1]) && isWall(array[i + 1, j]))
{
return LevelObject.WallURD;
}
// *
// **
// *
if (isWall(array[i - 1, j]) && isWall(array[i, j - 1]) && isWall(array[i, j + 1]))
{
return LevelObject.WallDLU;
}
// *
// ***
if (isWall(array[i, j - 1]) && isWall(array[i - 1, j]) && isWall(array[i + 1, j]))
{
return LevelObject.WallLUR;
}
// ***
// *
if (isWall(array[i, j + 1]) && isWall(array[i - 1, j]) && isWall(array[i + 1, j]))
{
return LevelObject.WallRDL;
}
// **
if (isWall(array[i, j - 1]) && isWall(array[i, j + 1]))
{
return LevelObject.WallVertic;
}
// *
// *
if (isWall(array[i - 1, j]) && isWall(array[i + 1, j]))
{
return LevelObject.Wall;
}
// *
// **
if (isWall(array[i + 1, j]) && isWall(array[i, j - 1]))
{
return LevelObject.WallUpRight;
}
// *
// **
if (isWall(array[i, j - 1]) && isWall(array[i - 1, j]))
{
return LevelObject.WallLeftUp;
}
// **
// *
if (isWall(array[i - 1, j]) && isWall(array[i, j + 1]))
{
return LevelObject.WallLeftDown;
}
// **
// *
if (isWall(array[i + 1, j]) && isWall(array[i, j + 1]))
{
return LevelObject.WallDownRight;
}
// если попали сюда - то неизвестная стена - возвращаем пустое место
return 0;
}
/// <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 GameSimpleObject(string __objectName, GameLevel __level, Engine.Logic.PivotObjectDependType __dependType = PivotObjectDependType.Body, bool __mouseRC = false, bool __bulletRC = false)
: base(__level, __mouseRC, __bulletRC)
{
_object = Engine.GameEngine.LoadObject(__objectName, null, __mouseRC, __bulletRC, __dependType) as LevelObject;
}
public void ReadObjects(int off)
{
int count = BitConverter.ToInt32(memory, off);
LObjects = new List<LevelObject>();
int pos = off + 4;
for (int i = 0; i < count; i++)
{
LevelObject l = new LevelObject();
l.entry = BitConverter.ToInt32(memory, pos) -1;
l.cls = "";
l.name = "";
if (l.entry >= 0 && l.entry < pcc.Export.Length)
{
l.name = pcc.names[pcc.Export[l.entry].Name];
l.cls = pcc.getClassName(pcc.Export[l.entry].Class);
}
LObjects.Add(l);
pos += 4;
}
}
public void Loaddata()
{
Scene = gameScene.Scene;
//если ты с горы упал - ты ешё не экстримал
//чтоб далеко не падать
groundplane = CreateGroundPlane();
///box
{
LevelObjectBox = LoadObject("WoodenCrate10WorldObject\0", null, true, true) as LevelObject;
LevelObjectBox.matrialType = PivotObjectMaterialType.DynamicWood;
LevelObjectBox.SetGlobalPose(Matrix.CreateRotationX(1.0f) * Matrix.CreateTranslation(0, 25, 0));
AddObjectToScene(LevelObjectBox);
}
float delta = 4;
int x = 5;
int y = 5;
for (int i = 0; i < x;i++ )
for (int j = 0; j < y; j++)
{
LevelObject lo = LoadObject("WoodenCrate10WorldObject\0", null, true, true) as LevelObject;
lo.matrialType = PivotObjectMaterialType.DynamicWood;
lo.SetGlobalPose(Matrix.CreateRotationX(1.0f) * Matrix.CreateTranslation(i * delta, 25, j * delta));
AddObjectToScene(lo);
}
////test side
{
LevelObjectTestSide = LoadObject("TestSideWorldObject\0", null, true, true) as LevelObject;
LevelObjectTestSide.SetGlobalPose(Matrix.CreateFromAxisAngle(new Vector3(1, 0, 0), -MathHelper.PiOver2) * Matrix.CreateTranslation(0, 15, 0));
AddObjectToScene(LevelObjectTestSide);
}
////palmbush1
{
LevelObject lo = LoadObject("lo_PalmBush1\0", null, false, false) as LevelObject;
lo.SetGlobalPose(Matrix.CreateFromAxisAngle(new Vector3(1, 0, 0), -MathHelper.PiOver2) * Matrix.CreateTranslation(-5, 15.0f, 2));
lo.CreateRenderSkew(0.03f);
AddObjectToScene(lo);
}
////palmbush2
{
LevelObject lo = LoadObject("lo_PalmBush2\0", null, false, false) as LevelObject;
lo.SetGlobalPose(Matrix.CreateFromAxisAngle(new Vector3(1, 0, 0), -MathHelper.PiOver2) * Matrix.CreateTranslation(-5, 15.0f, 0));
lo.CreateRenderSkew(0.03f);
AddObjectToScene(lo);
}
////grass1
{
LevelObject lo = LoadObject("lo_GrassBush1\0", null, false, false) as LevelObject;
lo.SetGlobalPose(Matrix.CreateFromAxisAngle(new Vector3(1, 0, 0), -MathHelper.PiOver2) * Matrix.CreateTranslation(-6, 15.0f, -1));
lo.CreateRenderSkew(0.1f);
AddObjectToScene(lo);
}
////particles
{
ParticleObject po = LoadParticleObject("Particle001RO\0", new Vector3(2));
po.SetGlobalPose(Matrix.CreateFromAxisAngle(new Vector3(1, 0, 0), -MathHelper.PiOver2) * Matrix.CreateTranslation(2, 15, 2));
po.SetParticlesParameters(10, Vector3.Up, 1.0f, -0.01f, 0.2f, 1.0f, 0.2f, 8000, 15);
po.FirstEmition();
gameScene.AddObject (po);
}
//чистим временные какахи
//это стоит делать елси объекты больше не будут подгружаться
//тоесть если игра по уровням скажем
// packs.Unload();
}
private void AddLevelObject(LevelObject loNew, Engine.Logic.PivotObject __parentObject = null)
{
if (loNew.renderaspect.isanimated)
{
Engine.Render.AnimRenderObject ro = loNew.renderaspect as Engine.Render.AnimRenderObject;
Engine.AnimationManager.AnimationManager.Manager.AddAnimationUser(ro);
}
_scene.AddObject(loNew);
if (__parentObject != null)
{
loNew.SetGlobalPose(Matrix.Identity, true, __parentObject);
_scene._objects.AddRule(__parentObject, loNew);
}
}
/// <summary>
/// Проверяет, является ли текущая клетка стеной
/// </summary>
/// <param name="element">Значение ячейки карты</param>
/// <returns>true - стена, false - нет</returns>
bool isWall(LevelObject element)
{
if ((int)element > 0 && (int)element <= 29) { // стены 1-11 и двери 20-23
return true;
}
return false;
}
/// <summary>
/// Алгоритм поиска минимального пути
/// </summary>
/// <param name="arr">Массив с картой уровня</param>
/// <param name="N">Размер массива (ширина)</param>
/// <param name="M">Размер массива (высота)</param>
/// <param name="x_f">Координата конечной точки Х</param>
/// <param name="y_f">Координата конечной точки У</param>
/// <returns>Список точек пути до конечной точки</returns>
public List<List<int>> Way(LevelObject[,] arr, int N, int M, int x_f, int y_f)
{
int[,] workarr = new int[N + 1, M + 1];
int k;
int max_k = N * M; // максимальное число итераций
int i, j;
int twice;
// заполняем рабочий массив
for (i = 0; i < N; i++)
{
for (j = 0; j < M; j++)
{
if (arr[i, j] == LevelObject.Empty)
workarr[i, j] = (int)Propety.FreeWay; // проходимо
else
workarr[i, j] = (int)Propety.Wall; // не проходимо
if (i == x && j == y)
workarr[i, j] = (int)Propety.Start; // старт
if (i == x_f && j == y_f)
workarr[i, j] = (int)Propety.Finish; // финиш
}
}
bool f_way = false; // есть ли путь
bool f_way_iter = true; // путь на данной итерации
// Распространение волны
k = 0;
// начинаем поиск.. сначала ищем финиш
while (!f_way && f_way_iter && k < max_k)
{
f_way_iter = false; // считаем что на данной итерации нет пути
for (i = 1; i < N - 1; i++)
{
for (j = 1; j < M - 1; j++)
{
if (workarr[i, j] == k)
{
twice = 0;
f_way_iter = true; // на данной итерации есть путь
do
{
for (int p = -1; p < 2; p = p + 2)
{
if (workarr[i + p * (-twice + 1), j + p * twice] == (int)Propety.Start) // дошли до старта => выходим из поиска
{
twice = 2;
i = N;
j = M;
f_way = true; // путь полностью найден
break;
}
if (workarr[i + p * (-twice + 1), j + p * twice] == (int)Propety.FreeWay)
workarr[i + p * (-twice + 1), j + p * twice] = k + 1;
}
twice++;
}
while (twice < 2);
}
}
}
k++;
}
if (!f_way)
return null; // Нет пути
// заполняем массив коордианатами
List<List<int>> ArrWay = new List<List<int>>();
ArrWay.Add(new List<int>());
int r = 0;
//стартовая координата
ArrWay[r].Add(x);
ArrWay[r].Add(y);
i = x;
j = y;
int min = workarr[i, j];
int i_m = i;
int j_m = j;
while (workarr[i, j] != (int)Propety.Finish) // прокладываем маршрут пока не дойдем до финиша
{
twice = 0;
// поиск минимального элемента из [i+1,j]; [i-1,j]; [i,j+1]; [i,j-1]
do
{
for (int p = -1; p < 2; p = p + 2)
{
if (workarr[i + p * (-twice + 1), j + p * twice] < min)
{
min = workarr[i + p * (-twice + 1), j + p * twice];
i_m = i + p * (-twice + 1);
j_m = j + p * twice;
}
}
twice++;
}
while (twice <= 1);
i = i_m;
j = j_m;
r++;
ArrWay.Add(new List<int>());// добавляем новую строку под координату
ArrWay[r].Add(i);
ArrWay[r].Add(j);
}
return ArrWay;
}
public WorldObjectTag(LevelObject obj)
{
Internal = obj;
}
static void Main(string[] args)
{
string appName = AppDomain.CurrentDomain.FriendlyName;
string outputDirectory = Environment.CurrentDirectory;
bool helpRequested = false;
bool verboseOutputRequested = false;
var optionSet = new OptionSet()
{
string.Format("Usage: {0} [OPTIONS] filename [filename ...]", appName),
"",
"Process jumpman level files (.lvl files).",
"",
" filename the path to a source file(s) to process.",
"",
"Options:",
{ "o|out=", "the {DIRECTORY} to place processed output.", value => outputDirectory = value },
{ "v|verbose", "write out extended runtime debug information.", value => verboseOutputRequested = value != null },
{ "h|help", "show this help message and exit.", value => helpRequested = value != null },
};
List<string> extra;
try
{
extra = optionSet.Parse(args);
}
catch (OptionException e)
{
Console.WriteLine("{0}:", appName);
Console.WriteLine(e.ToString());
Console.WriteLine("Try '{0} --help' for more information.", appName);
return;
}
Action writeUsage = () => optionSet.WriteOptionDescriptions(Console.Out);
var filenames = extra.Select(filename => Path.GetFullPath(filename)).ToList<string>();
var invalidFilenames = filenames.Where(filename => !File.Exists(filename)).ToList<string>();
if (helpRequested)
{
writeUsage();
return;
}
if (filenames.Count < 1)
{
Console.WriteLine("Must specify at least one filename.");
Console.WriteLine();
writeUsage();
return;
}
if (invalidFilenames.Any())
{
Console.WriteLine("Cannot find file(s):");
foreach (string invalidFilename in invalidFilenames)
{
Console.WriteLine(invalidFilename);
}
Console.WriteLine();
writeUsage();
return;
}
Action<string, object> logDebugMessage = (formatString, param0) =>
{
if (verboseOutputRequested)
{
Console.WriteLine(formatString, param0);
}
};
Action<string, object, object> logDebugMessage2 = (formatString, param0, param1) =>
{
if (verboseOutputRequested)
{
Console.WriteLine(formatString, param0, param1);
}
};
long levelResourceCount = 0;
LevelResource[] levelResources = new LevelResource[500];
long levelObjectCount = 0;
LevelObject[] levelObjects = new LevelObject[500];
foreach(int index in Enumerable.Range(0, levelObjects.Length))
{
levelObjects[index].V = new Vertex[9];
}
foreach (string filenameToRender in filenames)
{
string sourceFilename = Path.GetFileName(filenameToRender);
string sourceDirectory = Path.GetDirectoryName(filenameToRender);
string scriptBaseName = null;
logDebugMessage("Loading file: {0}", filenameToRender);
FileRoutines.LoadLevelFromFile(sourceFilename, sourceDirectory, ref scriptBaseName, ref levelObjectCount, ref levelObjects, ref levelResourceCount, ref levelResources);
logDebugMessage("Finished loading file: {0}", filenameToRender);
string binaryOutputFilename = Path.Combine(outputDirectory, scriptBaseName + ".dat");
string resourcesOutputFilename = Path.Combine(outputDirectory, scriptBaseName + "resources.jms");
logDebugMessage2("Rendering output to binary file: {0} and resources constants to resource script: {1}", binaryOutputFilename, resourcesOutputFilename);
FileRoutines.RenderLevelToFile(levelResourceCount, levelResources, levelObjectCount, levelObjects, scriptBaseName, sourceDirectory, outputDirectory);
logDebugMessage2("Finished rendering output to binary file: {0} and resources constants to resource script: {1}", binaryOutputFilename, resourcesOutputFilename);
}
}
/// <summary>
/// Ищет стены в каждую сторону от клетки, если хотя бы 1 стены нет, то клетка - пустота
/// </summary>
/// <param name="floorPositionX">Номер колонки</param>
/// <param name="floorPositionY">Номер строки</param>
/// <returns></returns>
private bool isFloor(LevelObject[,] levelFloor, int floorPositionX, int floorPositionY, int sizeLvlCols, int sizeLvlRows)
{
//floorPositionY -= sizeLvlRows;
int qWalls = 0;
for (int i = floorPositionX; i >= 0; i--)
{
if (levelFloor[i, floorPositionY] == LevelObject.Empty)
{
qWalls++;
break;
}
}
for (int i = floorPositionX; i <= sizeLvlCols; i++)
{
if (levelFloor[i, floorPositionY] == LevelObject.Empty)
{
qWalls++;
break;
}
}
for (int j = floorPositionY; j >= 0; j--)
{
if (levelFloor[floorPositionX, j] == LevelObject.Empty)
{
qWalls++;
break;
}
}
for (int j = floorPositionY; j <= sizeLvlRows; j++)
{
if (levelFloor[floorPositionX, j] == LevelObject.Empty)
{
qWalls++;
break;
}
}
if (qWalls == 4)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// запоминаем карту уровня
/// </summary>
/// <param name="tempLevelMap">Карта уровня в 0 и 1</param>
/// <param name="n">Кол-во столбцов</param>
/// <param name="m">Кол-во строк</param>
public static void SetLevelMap(LevelObject[,] tempLevelMap, int n, int m)
{
levelWidth = n;
levelHeight = m;
levelMap = new LevelObject[n, m];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
levelMap[i, j] = tempLevelMap[i, j];
}
}
}
Texture2D textureInactive; // текстура выключенного лазера
#endregion Fields
#region Constructors
/// <summary>
/// Конструктор лазера
/// </summary>
/// <param name="rect">Прямоугольник</param>
/// <param name="texture">Текстура лазера</param>
/// <param name="textureInactive">Текстура выключенного лазера</param>
/// <param name="typeLaser">Тип лазера</param>
/// <param name="game">ссылка на игру</param>
/// <param name="camera">ссылка на камеру</param>
public Cameras(Rectangle Rect, Texture2D texture, Texture2D textureInactive, LevelObject typeCamera, Game1 game, Camera camera)
: base(Rect, texture, game, camera)
{
this.textureInactive = textureInactive;
this.typeCamera = typeCamera;
}
private static void AddToLevel(LevelObject levelToAddTo, HierarchyTaskObject TO)
{
levelToAddTo.VisibleLevelCollection.Add(TO);
levelToAddTo.LevelCollection.Add(TO);
}
