Предыдущие части: Часть 0, Часть 1, Часть 2, Часть 3, Часть 4
4.7 Делаем из деревьев лес
В прошлый раз мы остановились на том, что с увеличением количества объектов все больше времени уходит на их обсчет, что, безусловно, логично. В нашем случае самым нагружающим моментом являются сегменты боковых стенок, из-за чего по-настоящему длинную трассу сделать не получалось. Итак, решим проблему с боковыми стенками. Строить границу трассы из «кирпичиков», каждый из которых обладает своим коллайдером - плохая идея, так как их в любом случае будет слишком много, и никакая оптимизация тут не поможет.
Можно прописать границу карты, за которую выходить нельзя, но тогда будет тяжело рисовать трассы более сложной формы, например, расширяющуюся или сужающуюся, поэтому я остановился на решении прописать возможность создания длинных блоков – легче обсчитывать один объект размерами 10х1, чем 10 объектов 1х1. Сначала проверим, поможет ли нам это, и создадим новый класс — Граница. Так как нижеследующий код является тестовым и потом я его уберу, то этот кусок буду показывать скриншотами.
Теперь уберем в инициализации генерацию боковых стенок, чтобы убрать тормоза:
И прямо под этим циклом делаем генератор длинных стенок.
Номера спрайта -1 в словаре нет, поэтому при отрисовке будет ошибка. Сделаем так, чтобы вместо этого отрисовки просто не происходило во View:
_spriteBatch.Begin(); foreach (var o in _objects.Values) { if (o.ImageId == -1) continue; _spriteBatch.Draw(_textures[o.ImageId], o.Pos - _visualShift, Color.White); } _spriteBatch.End();
Если запустим, то увидим, что длинные невидимые стенки нас останавливают:
Немного облегчим себе и компьютеру работу — создаем словарь, в котором будут храниться только твердые объекты:
<.........................................................> public Dictionary<int, ISolid> SolidObjects { get; set; } public void Initialize() { Objects = new Dictionary<int, IObject>(); SolidObjects = new Dictionary<int, ISolid>(); <..........................................................>
И немного меняем алгоритм генерации с учетом того, что у нас теперь есть этот словарь:
Теперь у нас есть проверка на «твердость» объекта, в результате которой объект добавляется в новый словарь, а, значит, нет необходимости приводить типы в обсчете коллизий — можно сразу обращаться к словарю, так как ключи в словаре твердых объектов соответствуют ключам объектов в общем словаре:
private void CalculateObstacleCollision( (Vector2 initPos, int Id) obj1, (Vector2 initPos, int Id) obj2 ) { bool isCollided = false; Vector2 oppositeDirection = new Vector2 (0, 0); while (RectangleCollider.IsCollided SolidObjects[obj1.Id].Collider, SolidObjects[obj1.Id].Collider)) { isCollided = true; if (obj1.initPos != Objects[obj1.Id].Pos) { oppositeDirection = Objects[obj1.Id].Pos - obj1.initPos; oppositeDirection.Normalize(); Objects[obj1.Id].Move(Objects[obj1.Id].Pos - oppositeDirection); } if (obj2.initPos != Objects[obj2.Id].Pos) { oppositeDirection = Objects[obj2.Id].Pos - obj2.initPos; oppositeDirection.Normalize(); Objects[obj2.Id].Move(Objects[obj2.Id].Pos - oppositeDirection); } } if (isCollided) { Objects.[obj1.Id].Speed = new Vector2(0, 0); Objects.[obj2.Id].Speed = new Vector2(0, 0); } }
Метод Update меняем так, чтобы в список сталкивающихся объектов попадали только объекты из списка твердых:
public void Update() { Vector2 playerInitPos = ObjectSecurity[PlayerId].Pos; Dictionary<int, Vector2> collisionObjects = new Dictionary<int, Vector2>(); foreach (var i in Objects.Keys) { Vector2 initPos = Objects[i].Pos; Objects[i].Update(); if (SolidObjects.ContainsKey(i)) collisionObjects.Add(i, initPos); } <............................................>
Запускаем, и видим потрясающую производительность, так как теперь обсчитывается не 1004 объекта, а всего 6 – три машинки, две пограничные стенки и одна стенка на трассе.
Теперь, пока не забыли, сделаем так, чтобы пары объектов не считались дважды:
public void Update() { Vector2 playerInitPos = ObjectSecurity[PlayerId].Pos; Dictionary<int, Vector2> collisionObjects = new Dictionary<int, Vector2>(); foreach (var i in Objects.Keys) { Vector2 initPos = Objects[i].Pos; Objects[i].Update(); if (SolidObjects.ContainsKey(i)) collisionObjects.Add(i, initPos); } List <(int, int)> processedObjects = new List<(int, int)>(); foreach (var i in collisionObjects.Keys) { foreach (var j in collisionObjects.Keys) { if (i == j || processedObjects.Contains((j, i))) continue; CalculateObstacleCollision( (collisionObjects[i],i), (collisionObjects[j],j) ); processedObjects.Add((i, j)); } } Vector2 playerShift = Objects[PlayerId].Pos - playerInitPos; Updated.Invoke(this, new GameplayEventArgs { Objects = Objects, POVShift = playerShift }); }
Есть еще один способ – прописывать препятствия карты через тайлы. То есть, проверять, где наш игрок согласно массиву и, если там стенка – не пускать его. Мне он не нравится, потому что он нарушает целостность структуры, которую я создал, поэтому прибегать к нему без необходимости я не буду. По крайней мере, пока.
4.8 Делаем лес видимым
Мы поняли, что стенки в виде единого объекта работают как надо, но теперь возникла проблема того, как их сгенерировать адекватно — во-первых, они сейчас невидимые, а даже если мы дадим им спрайт, то он будет короче, чем нужно, во-вторых, нужно как-то впихнуть приведенный выше хардкод в наш генератор.
Начнем с первой проблемы. Стенки трассы могут быть произвольной длины, а спрайты у нас могут быть только фиксированными. И эта проблема, теоретически, может появиться и потом – у объекта может быть не один спрайт, а больше. Поменяем структуру так, чтобы объект мог состоять из нескольких картинок, заменяя в интерфейсе объекта интовую переменную номера спрайта на словарь таких номеров:
public interface IObject { // Вместо одного спрайта будет список спрайтов List<(int ImageId, Vector2 ImagePos)> Sprites { get; set; } Vector2 Pos { get;} Vector2 Speed { get; set; } void Update(); void Move (Vector2 pos); }
Этот список хранит кортежи — номер спрайта и его позицию относительно позиции объекта. Таких образом, мы сможем размещать много спрайтов, которые относятся к одному объекту, в разных местах. Делаем аналогичную замену в классах, которые реализуют IObject - в полях и конструкторах:
<................................................................> public List<(int ImageId, Vector2 ImagePos)> Sprites { get; set; } public Car(Vector2 position) { Pos = position; IsLive = true; Sprites = new List<(int ImageId, Vector2 ImagePos)>(); Collider = new RectangleCollider((int)Pos.X, (int)Pos.Y, 77, 100); }
В методе Initialize игрового цикла пока комментим код генерации границ трассы, чтобы не мешались, а также меняем методы генерации машины и стенки в игровом цикле:
private Car CreateCar ( float x, float y, int spriteId, Vector2 speed) { Car c = new Car(); c.Sprites.Add(((byte)spriteId, Vector.Zero)); c.Pos = new Vector2(x, y); c.Speed = speed; return c; } private Wall CreateWall( float x, float y, int spriteId) { Wall w = new Wall(); c.Sprites.Add(((byte)spriteId, Vector.Zero)); w.Pos = new Vector2(x, y); w.ImageId = spriteId; return w; }
Соответствующим образом меняем метод отрисовки во View:
protected override void Draw(GameTime gameTime) { GraphicsDevice.Clear(Color.DarkSeaGreen); base.Draw(gameTime); _spriteBatch.Begin(); foreach (var o in _objects.Values) { // Перебираем все спрайты в списке и рисуем каждый foreach (var sprite in o.Sprites) { if (sprite.ImageId == -1) continue; _spriteBatch.Draw( _textures[sprite.ImageId], // Добавляем еще и смещение спрайта относительно позиции объекта o.Pos - _visualShift + sprite.ImagePos, Color.White ); } } _spriteBatch.End(); }
Теперь сделаем так, чтобы наши стенки имели произвольную длину и нормально отрисовывались. Для начала вернем им свойство твердости, а то потом забудем:
Добавляем стенке свойства длины и ширины (прошу прощения за скриншот, но так нагляднее):
А теперь поменяем метод генерации в игровом цикле так, чтобы наши спрайты множились в соответствии с размерам коллайдера:
private Wall CreateWall (float x, float y, ObjectTypes spriteId) { int width = 24; int length = 2000; Wall w = new Wall (new Vector2(x,y), width, length); for (int i = 0; i < width; i+=24) for (int j = 0; j < length; j+=100) { w.Sprites.Add(((byte)spriteId, new Vector2(i,j))); } return w; }
Теперь разместим стенки на карте:
public void Initialize() { Objects = new Dictionary<int, IObject>(); SolidObjects = new Dictionary<int, ISolid>(); _map[5, 7] = 'P'; _map[4, 4] = 'C'; _map[6, 2] = 'C'; _map[0, 0] = 'W'; _map[_map.GetLength(0)-1, 0] = 'W'; }
При такой реализации мы размещаем левый верхний угол стены, а все остальное строится уже относительно него:
Класс Border теперь не нужен — можно его удалить.
Следующим этапом пропишем, чтобы размер стенки не хардкодился, а нормально задавался через массив карты. Для начала сделаем перегруженный метод GenerateObject специально для тех случаев, когда объект может иметь произвольные размеры:
private IObject GenerateObject(char sign, int xInitTile, int yInitTile, int xEndTile, int yEndTile) { float xInit = xInitTile * _tileSize; float yInit = yInitTile * _tileSize; float xEnd = xEndTile * _tileSize; float yEnd = yEndTile * _tileSize; IObject generatedObject = null; if (sign == 'W') { generatedObject = CreateWall (xInit + _tileSize / 2, yInit + _tileSize / 2, xEnd + _tileSize / 2, yEnd + _tileSize / 2, spriteId: ObjectTypes.wall); } return generatedObject; }
Генерация стенки без хардкода будет выглядеть следующим образом:
private Wall CreateWall (float xInit, float yInit, float xEnd, float yEnd, ObjectTypes spriteId) { int width = Math.Abs(xEnd - xInit) == 0 ? 24 : (int)Math.Abs(xEnd - xInit); int length = Math.Abs(yEnd - yInit) == 0 ? 100 : (int)Math.Abs(yEnd - yInit); Wall w = new Wall (new Vector2(xInit, yInit), width, length); for (int i = 0; i < width; i+=24) for (int j = 0; j < length; j+=100) { w.Sprites.Add(((byte)spriteId, new Vector2(i,j))); } return w; }
Теперь нужно изменить обработчик массива карты так, чтобы стенка корректно генерировалась:
<................................................................> for (int y = 0; y < _map.GetLength(1); y++) for (int x = 0; x < _map.GetLength(0); x++) { if (_map.GameField[x, y] != '\0') { IObject generatedObject = null; if (int.TryParse(_map[x, y].ToString(), out int corner1)) { for (int yCorner = 0; yCorner < _map.GetLength(1); yCorner++) for (int xCorner = 0; xCorner < _map.GetLength(0); xCorner++) { if (int.TryParse ( _map[xCorner, yCorner].ToString(), out int corner2) ) { if (corner1==corner2) { generatedObject = GenerateObject('W', x, y, xCorner, yCorner); _map[x, y] = '\0'; _map[xCorner, yCorner] = '\0'; } } } } else { generatedObject = GenerateObject(_map[x, y], x, y); } <................................................................>
Принцип работы следующий — если мы хотим разместить стенку, то в ячейке массива записываем цифру и дальше ищем внутри массива вторую такую же. Тогда первая цифра будет задавать координату левого верхнего угла, а вторая — правого нижнего. Таким образом легко получить геометрические размеры нашей стенки, которые можно подать на метод генерации. После этой операции цифры удаляем из массива, чтобы они не мешались.
Создадим в нашем массиве границы и запустим программу:
public void Initialize() { Objects = new Dictionary<int, IObject>(); SolidObjects = new Dictionary<int, ISolid>(); _map[5, 7] = 'P'; _map[4, 4] = 'C'; _map[6, 2] = 'C'; _map[0, 0] = '1'; _map[0, 10] = '1'; _map[_map.GetLength(0)-1, 0] = '2'; _map[_map.GetLength(0)-1, 10] = '2'; }
Работает =)
Можно даже сделать стенки толстыми:
public void Initialize() { Objects = new Dictionary<int, IObject>(); SolidObjects = new Dictionary<int, ISolid>(); _map[5, 7] = 'P'; _map[4, 4] = 'C'; _map[6, 2] = 'C'; _map[0, 1] = '1'; _map[1, 10] = '1'; _map[_map.GetLength(0)-1, 1] = '2'; _map[_map.GetLength(0)-1, 10] = '2'; _map[0, 0] = '3'; _map[_map.GetLength(0)-1, 0] = '3'; }
Недостатком здесь является то, что типы стенок мы указывать не можем, так как массив у нас чаровый. Но, думаю, в рамках разрабатываемой игры это не страшно.
Минутка рефакторинга
Давайте, теперь уберем слона из комнаты и сделаем так, чтобы размеры наших коллайдеров не хардкодились. Хардкод все равно будет, но там, где это не бесит.
Создаем статический класс с названием Фабрика (к паттернам не имеет отношения), куда переносим наши методы генерации машинки и стены. Кроме того, переносим сюда enum, где хранятся номера спрайтов:
public static class Factory { private static Dictionary<string, (byte type, int width, int height)> _objects = new Dictionary<string, (byte, int, int)>(); { {"classicCar", ((byte)ObjectTypes.car, 77, 100)}, {"wall", ((byte)ObjectTypes.wall, 24, 100)}, }; public static Car CreateClassicCar (float x, float y, Vector2 speed) { Car c = new Car (new Vector2 (x, y)); c.Sprites.Add((_objects["classicCar"].type, Vector2.Zero)); c.Speed = speed; return c; } public static Wall CreateWall (float xInit, float yInit, float xEnd, float yEnd) { int segmentWidth = _objects["wall"].width; int segmentHeight = _objects["wall"].height; int width = Math.Abs(xEnd - xInit) == 0 ? segmentWidth : (int)Math.Abs(xEnd - xInit); int length = Math.Abs(yEnd - yInit) == 0 ? segmentHeight : (int)Math.Abs(yEnd - yInit); Wall w = new Wall (new Vector2(xInit, yInit), width, length); for (int i = 0; i < width; i+=24) for (int j = 0; j < length; j+=100) { w.Sprites.Add((_objects["wall"].type, new Vector2(i,j))); } return w; } public enum ObjectTypes : byte { car, wall } }
Создаем словарь _objects, который как раз и будет содержать номер спрайта и параметры коллайдера соответствующего объекта. Суть в том, что генерировать любой объект мы будем через методы класса Factory и весь некрасивый хардкод будет храниться здесь.
Остается поменять под новый класс наш GameCycle:
private IObject GenerateObject(char sign, int xTile, int yTile) { float x = xTile * _tileSize; float y = yTile * _tileSize; IObject generatedObject = null; if (sign == 'P' || sign == 'C') { generatedObject = Factory.CreateClassicCar ( x + _tileSize / 2, y + _tileSize / 2, speed: new Vector2 (0, 0)); } return generatedObject; } private IObject GenerateObject(char sign, int xInitTile, int yInitTile, int xEndTile, int yEndTile) { float xInit = xInitTile * _tileSize; float yInit = yInitTile * _tileSize; float xEnd = xEndTile * _tileSize; float yEnd = yEndTile * _tileSize; IObject generatedObject = null; if (sign == 'W') { generatedObject = Factory.CreateWall (xInit + _tileSize / 2, yInit + _tileSize / 2, xEnd + _tileSize / 2, yEnd + _tileSize / 2, spriteId: ObjectTypes.wall); } return generatedObject; }
Обратите внимание, что в этом классе мы теперь только указываем, где сгенерировать объект и скорость для машины. Все технические внутренности задает Фабрика по жестко заданному плану.
И не забудем поменять ссылку на номера спрайтов во View:
А на сегодня все. В следующий раз, наконец, сможем уже заняться геймплеем!
