public void AddToActive(ref byte[] items, int numberOfItemsInArray, ref TileCollection tile)
{
if (_itemCollectionsInActive.Count < numberOfItemsInArray)
{
_itemCollectionsActive.Sort();
var numberToFreeUp = numberOfItemsInArray - _itemCollectionsInActive.Count;
numberToFreeUp = numberToFreeUp > _itemCollectionsActive.Count
? _itemCollectionsActive.Count
: numberToFreeUp;
var actuallyRemoved = 0;
for (var i = 0; i < numberToFreeUp; i++)
{
var item = _itemCollectionsActive[i];
if (item.InInventory) break;
actuallyRemoved++;
_itemCollectionsInActive.Enqueue(item);
}
for (var j = 0; j < actuallyRemoved; j++)
_itemCollectionsActive.RemoveAt(j);
numberOfItemsInArray = _itemCollectionsInActive.Count+actuallyRemoved;
}
for (var i = 0; i < numberOfItemsInArray; i++)
{
var newWic = _itemCollectionsInActive.Dequeue();
_itemCollectionsActive.Add(newWic);
SetItems(ref items[i], ref tile, ref newWic);
}
}
private void IsClosestRect(ref TileCollection testColl, ref int smallestDifference)
{
if (!testColl.HitRect.Intersects(HitRect)) return;
var newestX = testColl.HitRect.Center.X - HitRect.Center.X;
newestX = newestX < 0 ? -newestX : newestX;
var newestY = testColl.HitRect.Center.Y - HitRect.Center.Y;
newestY = newestY < 0 ? -newestY : newestY;
if (smallestDifference > newestX + newestY)
{
smallestDifference = newestX + newestY;
#if DEBUG
MyTile.ShowHitBox = false;
#endif
_myTile = testColl;
#if DEBUG
MyTile.ShowHitBox = true;
#endif
}
}
private void CheckTileForLoot(ref TileCollection tileCollection)
{
var len = tileCollection.ItemsOnTile.Count;
for (var i = 0; i < len; i++)
{
var wi = tileCollection.ItemsOnTile[i];
if (!wi.HitRect.Intersects(_lootRect)) continue;
wi.Loot(this);
}
}
public void LoadData()
{
_position = Camera2D.MyCam.Position + _centerPosition;
_hitRect.X = (int) _position.X + 0;
_hitRect.Y = (int) _position.Y + 25;
for (var x = 0; x < TileManager.TileColls.GetLength(0); x++)
{
for (var y = 0; y < TileManager.TileColls.GetLength(1); y++)
{
if (TileManager.TileColls[x, y].HitRect.Intersects(HitRect))
{
_myTile = TileManager.TileColls[x, y];
break;
}
}
if (MyTile != null)
break;
}
#if DEBUG
MyTile.ShowHitBox = true;
#endif
}
internal void LoadData(ref LoaderBase[][] cl)
{
_tileLoaders = cl;
_terrainTileCollectionWidth = Convert.ToInt16(ScreenBuffer/64);
_terrainTileCollectionHeight = _terrainTileCollectionWidth;
_tileColls = new TileCollection[_terrainTileCollectionWidth,_terrainTileCollectionHeight];
_terrainTextureOne = new RenderTarget2D(MainGame.GraphicD, ScreenBuffer, ScreenBuffer);
_terrainTextureTwo = new RenderTarget2D(MainGame.GraphicD, ScreenBuffer, ScreenBuffer);
_terrainPosition = Vector2.Zero;
_graphicsDevice = MainGame.GraphicD;
for (var i = 0; i < _terrainTileCollectionWidth; i ++)
{
for (var j = 0; j < _terrainTileCollectionHeight; j ++)
{
var tc = new TileCollection(_tileRegions, i, j, _terrainTileCollectionWidth,
_terrainTileCollectionHeight);
_tileColls[i, j] = tc;
if (i == 0 && j == 0)
_mostLeftUpSprite = tc;
else if (_terrainTileCollectionWidth - 1 == i && _terrainTileCollectionHeight - 1 == j)
_mostRightDownSprite = tc;
tc.SectorX = PlayScreen.SpawnX;
tc.SectorY = PlayScreen.SpawnY;
tc.MySectorSpotX = i;
tc.MySectorSpotY = j;
tc.SetPosition(i*Sprite2XWidth, j*Sprite2XWidth);
var ar = GetSurroundings(ref tc.MyLoaderBase, tc.SectorX, tc.SectorY, tc.MySectorSpotX,
tc.MySectorSpotY);
tc.SetSurroundings(FindSurroundings(ar));
}
}
InitialDraw();
TileColls = _tileColls;
_terrainLoaded = true;
}
public void MoveTerrainUp()
{
//System.Diagnostics.Debug.WriteLine("hit tiles Move up");
// System.out.println("hit up");
var wasTheLastOfLoader = _mostRightDownSprite.MySectorSpotY == 0;
var oldVectorY = _mostRightDownSprite.MyVectorSpotY;
//new right values
var newSectorY = _mostLeftUpSprite.MySectorSpotY - 1 < 0
? _mostLeftUpSprite.SectorY - 1
: _mostLeftUpSprite.SectorY;
var newSectorSpotY = _mostLeftUpSprite.MySectorSpotY - 1 < 0
? PlayScreen.SectorTileSize - 1
: _mostLeftUpSprite.MySectorSpotY - 1;
var newPositionY = _mostLeftUpSprite.HitRect.Y - Sprite2XWidth;
//switch leftpos/rightpos sprites
_mostRightDownSprite =
TileColls[
_mostRightDownSprite.MyVectorSpotX,
_mostRightDownSprite.MyVectorSpotY - 1 < 0
? _terrainTileCollectionHeight - 1
: _mostRightDownSprite.MyVectorSpotY - 1];
_mostLeftUpSprite =
TileColls[
_mostLeftUpSprite.MyVectorSpotX,
_mostLeftUpSprite.MyVectorSpotY - 1 < 0
? _terrainTileCollectionHeight - 1
: _mostLeftUpSprite.MyVectorSpotY - 1];
for (var innerlooper = 0; innerlooper < _terrainTileCollectionWidth; innerlooper++)
{
var oldSprite = TileColls[innerlooper, oldVectorY];
oldSprite.SetPosition(oldSprite.HitRect.X, newPositionY);
oldSprite.SectorY = newSectorY;
oldSprite.MySectorSpotY = newSectorSpotY;
var ar = GetSurroundings(ref oldSprite.MyLoaderBase, oldSprite.SectorX, oldSprite.SectorY,
oldSprite.MySectorSpotX, oldSprite.MySectorSpotY);
oldSprite.SetSurroundings(FindSurroundings(ar));
}
if (_mostLeftUpSprite.SectorY != _tileLoaders[1][1].SectorY && wasTheLastOfLoader)
{
if (_tileLoaders[1][0].SectorY == _mostLeftUpSprite.SectorY)
_manager.MoveLoaderBase(MoveConstants.Up);
else
_manager.MoveLoaderBase(MoveConstants.Down);
}
PreDraw(MoveConstants.Up);
}
public void MoveTerrainRight()
{
//System.Diagnostics.Debug.WriteLine("hit tiles Move right");
var wasTheLastOfLoader = _mostLeftUpSprite.MySectorSpotX + 1 >= PlayScreen.SectorTileSize;
//old left values
var oldVectorX = _mostLeftUpSprite.MyVectorSpotX;
//new right values
var newSectorX = _mostRightDownSprite.MySectorSpotX + 1 >= PlayScreen.SectorTileSize
? _mostRightDownSprite.SectorX + 1
: _mostRightDownSprite.SectorX;
var newSectorSpotX = _mostRightDownSprite.MySectorSpotX + 1 >= PlayScreen.SectorTileSize
? 0
: _mostRightDownSprite.MySectorSpotX + 1;
var newPositionX = _mostRightDownSprite.HitRect.X + Sprite2XWidth;
//switch leftpos/rightpos sprites
_mostLeftUpSprite =
TileColls[
_mostLeftUpSprite.MyVectorSpotX + 1 >= _terrainTileCollectionWidth
? 0
: _mostLeftUpSprite.MyVectorSpotX + 1, _mostLeftUpSprite.MyVectorSpotY];
_mostRightDownSprite =
TileColls[
_mostRightDownSprite.MyVectorSpotX + 1 >= _terrainTileCollectionWidth
? 0
: _mostRightDownSprite.MyVectorSpotX + 1, _mostRightDownSprite.MyVectorSpotY];
for (var innerlooper = 0; innerlooper < _terrainTileCollectionHeight; innerlooper++)
{
var oldSprite = TileColls[oldVectorX, innerlooper];
oldSprite.SetPosition(newPositionX, oldSprite.HitRect.Y);
oldSprite.SectorX = newSectorX;
oldSprite.MySectorSpotX = newSectorSpotX;
var ar = GetSurroundings(ref oldSprite.MyLoaderBase, oldSprite.SectorX, oldSprite.SectorY,
oldSprite.MySectorSpotX, oldSprite.MySectorSpotY);
oldSprite.SetSurroundings(FindSurroundings(ar));
}
if (_mostRightDownSprite.SectorX != _tileLoaders[1][1].SectorX && wasTheLastOfLoader)
{
if (_tileLoaders[2][1].SectorX == _mostRightDownSprite.SectorX)
_manager.MoveLoaderBase(MoveConstants.Right);
else
_manager.MoveLoaderBase(MoveConstants.Left);
}
PreDraw(MoveConstants.Right);
}
public void MoveUp(TileCollection mostUpColl, TileCollection mostDownColl)
{
//System.Diagnostics.Debug.WriteLine("hit Decor Move up");
for (byte innerlooper = 0; innerlooper < _tileCollWidth; innerlooper++)
{
var mostDownYVal = mostDownColl.MyVectorSpotY + 1 >= _tileCollHeight
? 0
: mostDownColl.MyVectorSpotY + 1;
var s = DecorSprites[innerlooper, mostUpColl.MyVectorSpotY];
var currColl = _tileColls[innerlooper, mostUpColl.MyVectorSpotY];
s.SectorX = currColl.SectorX;
s.SectorY = currColl.SectorY;
s.MySectorSpotX = currColl.MySectorSpotX;
s.MySectorSpotY = currColl.MySectorSpotY;
s.UpdatePosition(currColl.HitRect.X, currColl.HitRect.Y);
var ld = currColl.MyLoaderBase;
DecorSprites[innerlooper, mostDownYVal].SetInfo(null, DecorHelper.None);
//currColl.CheckLightOfNeighbor(ref _tileColls, _tileCollWidth, _tileCollHeight);
CreateLightForTile(s, ld);
}
}
public void MoveRight(TileCollection mostLeftColl, TileCollection mostRightColl)
{
for (byte innerlooper = 0; innerlooper < _tileCollHeight; innerlooper++)
{
var mostUpYVal = mostLeftColl.MyVectorSpotX - 1 >= 0
? mostLeftColl.MyVectorSpotX - 1
: _tileCollWidth - 1;
var s = DecorSprites[mostRightColl.MyVectorSpotX, innerlooper];
var currColl = _tileColls[mostRightColl.MyVectorSpotX, innerlooper];
s.SectorX = currColl.SectorX;
s.SectorY = currColl.SectorY;
s.MySectorSpotX = currColl.MySectorSpotX;
s.MySectorSpotY = currColl.MySectorSpotY;
s.UpdatePosition(currColl.HitRect.X, currColl.HitRect.Y);
var ld = currColl.MyLoaderBase;
DecorSprites[mostUpYVal, innerlooper].SetInfo(null, DecorHelper.None);
//currColl.CheckLightOfNeighbor(ref _tileColls, _tileCollWidth, _tileCollHeight);
CreateLightForTile(s, ld);
}
}
private void SetItems(ref byte item, ref TileCollection tile, ref WorldItem worldItem)
{
var tileXPos = _random.Next(-1, 1);
var tileYPos = _random.Next(-1, 1);
var offsetx = _random.Next(TileManager.Sprite2XWidth);
var offsety = _random.Next(TileManager.Sprite2XWidth);
var newTileX = tileXPos < 0 ? tile.LeftVectorX : tileXPos > 0 ? tile.RightVectorX : tile.MyVectorSpotX;
var newTileY = tileYPos < 0 ? tile.TopVectorY : tileYPos > 0 ? tile.BottomVectorY : tile.MyVectorSpotY;
var newTile = TileManager.TileColls[newTileX, newTileY];
worldItem.SetType(ref newTile, item, newTile.HitRect.X + offsetx, newTile.HitRect.Y + offsety);
}
internal void SetTile(ref TileCollection startTile)
{
_myTile = startTile;
_myTile.AddWorldItem(this, true);
}
public void SetType(ref TileCollection myTile, byte type, float positionX, float positionY)
{
MyType = type;
Count = 1;
_myRegion = WorldItemKey.ItemRegions[type];
_hitRect.Width = _myRegion.Bounds.Width;
_hitRect.Height = _myRegion.Bounds.Height;
PutOnGround(positionX, positionY);
SetTile(ref myTile);
}
