public void ChangePhysicalMap(PhysicalMap map)
{
int firstBorder;
if (location.Y + size.Height > map.Height)
{
firstBorder = map.Height;
}
else
{
firstBorder = location.Y + size.Height;
}
int secondBorder;
if (location.X + size.Width > map.Width)
{
secondBorder = map.Width;
}
else
{
secondBorder = location.X + size.Width;
}
for (int i = location.Y; i < firstBorder; i++)
{
for (int j = location.X; j < secondBorder; j++)
{
map.MapMatrix[i][j] = (int)PhysicalMap.KindOfArea.EXPLOSION;
}
}
}
public GameCoreServer
(
int width, int height, Size playerSize, Size playerOnDeathSize,
Size bombSize, Size explosionSize, Size wallSize, string dirResources, SendFunc sendFunc
)
{
this.map = new PhysicalMap(width, height);
objectsList = new ObjectsLists();
spawnPoints = new List <Point>();
this.sendFunc = sendFunc;
timer = new Timer();
delay = 60;
timer.Interval = delay;
timer.Elapsed += TimerEvent;
randomGen = new Random();
scriptEngine = new ScriptEngine();
this.playerSize = playerSize;
this.bombSize = bombSize;
this.explosionSize = explosionSize;
this.wallSize = wallSize;
this.playerOnDeathSize = playerOnDeathSize;
GenerateWalls();
}
public virtual void ChangeMapMatrix(PhysicalMap PhysicalMap)
{
for (int i = Y; i < Y + size.Height; i++)
{
for (int j = X; j < X + size.Width; j++)
{
PhysicalMap.MapMatrix[i][j] = (int)PhysicalMap.KindOfArea.BOMB;
}
}
}
public void ClearPrevPlace(PhysicalMap PhysicalMap)
{
for (int i = Y; i < Y + size.Height; i++)
{
for (int j = X; j < X + size.Width; j++)
{
PhysicalMap.MapMatrix[i][j] = 0;
}
}
}
public override void ChangeMapMatrix(PhysicalMap PhysicalMap)
{
for (int i = Y; i < Y + size.Height; i++)
{
for (int j = X; j < X + size.Width; j++)
{
PhysicalMap.MapMatrix[i][j] = (int)PhysicalMap.KindOfArea.PLAYER;
}
}
}
public Explosion
(
Size size, Point location, int radius,
PhysicalMap map, OnEndAllExplosionFunc funcEnd
)
{
onEndAllExplosionFunc = funcEnd;
explosionLocation = location;
this.size = size;
this.radius = radius;
InitExplosion(size, location, radius, map);
ChangeState();
}
public bool isWallBlowedUp(PhysicalMap map)
{
for (int i = Y; i < Y + size.Height; i++)
{
for (int j = X; j < X + size.Width; j++)
{
if (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.EXPLOSION)
{
return(true);
}
}
}
return(false);
}
public Explosion
(
Image explosionTextureCenter, Image explosionTextureUpEdge,
Image explosionTextureBottomEdge, Image explosionTextureLeftEdge,
Image explosionTextureRightEdge, Image explosionTextureVerticalMiddle,
Image explosionTextureHorizontalMiddle, Size size, Point location, int radius,
PhysicalMap map, OnEndAllExplosionFunc funcEnd
)
{
onEndAllExplosionFunc = funcEnd;
explosionLocation = location;
this.size = size;
this.radius = radius;
InitExplosion(explosionTextureCenter, explosionTextureUpEdge, explosionTextureBottomEdge, explosionTextureLeftEdge,
explosionTextureRightEdge, explosionTextureVerticalMiddle, explosionTextureHorizontalMiddle,
size, location, radius, map);
ChangeState();
}
public void ChangePhysicalMap(PhysicalMap map)
{
for (int i = 0; i < partsExplosionBottom.Count; i++)
{
partsExplosionBottom[i].ChangePhysicalMap(map);
}
for (int i = 0; i < partsExplosionUp.Count; i++)
{
partsExplosionUp[i].ChangePhysicalMap(map);
}
for (int i = 0; i < partsExplosionLeft.Count; i++)
{
partsExplosionLeft[i].ChangePhysicalMap(map);
}
for (int i = 0; i < partsExplosionRight.Count; i++)
{
partsExplosionRight[i].ChangePhysicalMap(map);
}
partExplosionCenter.ChangePhysicalMap(map);
}
private bool canWePlaceExplosion(int X, int Y, PhysicalMap map, ExplosionDirection direction)
{
bool result = false;
lock (map.MapMatrix)
{
switch (direction)
{
case ExplosionDirection.UP:
{
for (int j = X; j < X + size.Width; j++)
{
for (int k = Y; (k < Y + size.Height) && (k < map.Height); k++)
{
if (map.MapMatrix[k][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int i = Y;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
i++;
}
newLocation.X = X;
newLocation.Y = i - 1;
return(true);
}
}
}
}
break;
case ExplosionDirection.DOWN:
{
for (int j = X; j < X + size.Width; j++)
{
for (int k = Y + size.Height; (k > Y) && (k > 0); k--)
{
if (map.MapMatrix[k][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int i = Y + size.Height;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
i--;
}
newLocation.X = X;
newLocation.Y = i - size.Height + 2;
return(true);
}
}
}
}
break;
case ExplosionDirection.LEFT:
{
for (int i = Y; i < Y + size.Height; i++)
{
for (int k = X; (k < X + size.Width) && (k < map.Width); k++)
{
if (map.MapMatrix[i][k] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int j = X;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
j++;
}
newLocation.X = j;
newLocation.Y = Y;
return(true);
}
}
}
}
break;
case ExplosionDirection.RIGHT:
{
for (int i = Y; i < Y + size.Height; i++)
{
for (int k = X + size.Width; (k > X) && (k > 0); k--)
{
if (map.MapMatrix[i][k] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int j = X + size.Width;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
j--;
}
newLocation.X = j - size.Width + 2;
newLocation.Y = Y;
return(true);
}
}
}
}
break;
}
return(result);
}
}
private void InitExplosion
(
Size size, Point location, int radius,
PhysicalMap map
)
{
const int countStates = 7;
partsExplosionBottom = new List <PartExplosion>();
partsExplosionLeft = new List <PartExplosion>();
partsExplosionRight = new List <PartExplosion>();
partsExplosionUp = new List <PartExplosion>();
countParts = 0;
for (int i = 0; i < radius; i++)
{
if ((location.X - size.Width * (i + 1)) > 0)
{
if (!canWePlaceExplosion(location.X - size.Width * (i), location.Y, map, ExplosionDirection.LEFT))
{
if (i < radius - 1)
{
partsExplosionLeft.Add(new PartExplosion(KindExplosionTexture.explosionTextureHorizontalMiddle, size, new Point((location.X - size.Width * (i + 1)), location.Y), countStates, onEndExplosionFunc));
}
else
{
partsExplosionLeft.Add(new PartExplosion(KindExplosionTexture.explosionTextureLeftEdge, size, new Point((location.X - size.Width * (i + 1)), location.Y), countStates, onEndExplosionFunc));
}
countParts++;
}
else
{
partsExplosionLeft.Add(new PartExplosion(KindExplosionTexture.explosionTextureHorizontalMiddle, size, new Point(newLocation.X, newLocation.Y), countStates, onEndExplosionFunc));
break;
}
}
else
{
if (i < radius - 1)
{
partsExplosionLeft.Add(new PartExplosion(KindExplosionTexture.explosionTextureHorizontalMiddle, size, new Point(0, location.Y), countStates, onEndExplosionFunc));
}
else
{
partsExplosionLeft.Add(new PartExplosion(KindExplosionTexture.explosionTextureLeftEdge, size, new Point(0, location.Y), countStates, onEndExplosionFunc));
}
countParts++;
break;
}
}
for (int i = 0; i < radius; i++)
{
if ((location.X + size.Width * (i + 1)) < map.Width)
{
if (!canWePlaceExplosion(location.X + size.Width * (i), location.Y, map, ExplosionDirection.RIGHT))
{
if (i < radius - 1)
{
partsExplosionRight.Add(new PartExplosion(KindExplosionTexture.explosionTextureHorizontalMiddle, size, new Point((location.X + size.Width * (i + 1)), location.Y), countStates, onEndExplosionFunc));
}
else
{
partsExplosionRight.Add(new PartExplosion(KindExplosionTexture.explosionTextureRightEdge, size, new Point((location.X + size.Width * (i + 1)), location.Y), countStates, onEndExplosionFunc));
}
countParts++;
}
else
{
partsExplosionLeft.Add(new PartExplosion(KindExplosionTexture.explosionTextureHorizontalMiddle, size, new Point(newLocation.X, newLocation.Y), countStates, onEndExplosionFunc));
break;
}
}
else
{
if (i < radius - 1)
{
partsExplosionRight.Add(new PartExplosion(KindExplosionTexture.explosionTextureHorizontalMiddle, size, new Point((map.Width - size.Width), location.Y), countStates, onEndExplosionFunc));
}
else
{
partsExplosionRight.Add(new PartExplosion(KindExplosionTexture.explosionTextureRightEdge, size, new Point(map.Width - size.Width, location.Y), countStates, onEndExplosionFunc));
}
countParts++;
break;
}
}
for (int i = 0; i < radius; i++)
{
if ((location.Y - size.Height * (i + 1)) > 0)
{
if (!canWePlaceExplosion(location.X, location.Y - size.Height * (i), map, ExplosionDirection.UP))
{
if (i < radius - 1)
{
partsExplosionUp.Add(new PartExplosion(KindExplosionTexture.explosionTextureVerticalMiddle, size, new Point(location.X, location.Y - size.Height * (i + 1)), countStates, onEndExplosionFunc));
}
else
{
partsExplosionUp.Add(new PartExplosion(KindExplosionTexture.explosionTextureUpEdge, size, new Point(location.X, location.Y - size.Height * (i + 1)), countStates, onEndExplosionFunc));
}
countParts++;
}
else
{
partsExplosionUp.Add(new PartExplosion(KindExplosionTexture.explosionTextureVerticalMiddle, size, new Point(newLocation.X, newLocation.Y), countStates, onEndExplosionFunc));
break;
}
}
else
{
if (i < radius - 1)
{
partsExplosionUp.Add(new PartExplosion(KindExplosionTexture.explosionTextureVerticalMiddle, size, new Point(location.X, 0), countStates, onEndExplosionFunc));
}
else
{
partsExplosionUp.Add(new PartExplosion(KindExplosionTexture.explosionTextureUpEdge, size, new Point(location.X, 0), countStates, onEndExplosionFunc));
}
countParts++;
break;
}
}
for (int i = 0; i < radius; i++)
{
if ((location.Y + size.Height * (i + 1)) < map.Height)
{
if (!canWePlaceExplosion(location.X, location.Y + size.Height * (i), map, ExplosionDirection.DOWN))
{
if (i < radius - 1)
{
partsExplosionBottom.Add(new PartExplosion(KindExplosionTexture.explosionTextureVerticalMiddle, size, new Point(location.X, location.Y + size.Height * (i + 1)), countStates, onEndExplosionFunc));
}
else
{
partsExplosionBottom.Add(new PartExplosion(KindExplosionTexture.explosionTextureBottomEdge, size, new Point(location.X, location.Y + size.Height * (i + 1)), countStates, onEndExplosionFunc));
}
countParts++;
}
else
{
partsExplosionUp.Add(new PartExplosion(KindExplosionTexture.explosionTextureVerticalMiddle, size, new Point(newLocation.X, newLocation.Y), countStates, onEndExplosionFunc));
break;
}
}
else
{
if (i < radius - 1)
{
partsExplosionBottom.Add(new PartExplosion(KindExplosionTexture.explosionTextureVerticalMiddle, size, new Point(location.X, map.Height - size.Height), countStates, onEndExplosionFunc));
}
else
{
partsExplosionBottom.Add(new PartExplosion(KindExplosionTexture.explosionTextureBottomEdge, size, new Point(location.X, map.Height - size.Height), countStates, onEndExplosionFunc));
}
countParts++;
break;
}
}
partExplosionCenter = new PartExplosion(KindExplosionTexture.explosionTextureCenter, size, location, countStates, onEndExplosionFunc);
countParts++;
}
public bool isObjectOnWay(PhysicalMap map)
{
lock (map.MapMatrix)
{
bool result = false;
switch (direction)
{
case Direction.UP:
{
for (int j = X; j < X + size.Width; j++)
{
if (map.MapMatrix[Y - 1][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int i = Y;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
i++;
}
newLocation.X = X;
newLocation.Y = i;
return(true);
}
}
}
break;
case Direction.DOWN:
{
for (int j = X; j < X + size.Width; j++)
{
if (map.MapMatrix[Y + size.Height][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int i = Y + size.Height;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
i--;
}
newLocation.X = X;
newLocation.Y = i - size.Height + 1;
return(true);
}
}
}
break;
case Direction.LEFT:
{
for (int i = Y; i < Y + size.Height; i++)
{
if (map.MapMatrix[i][X - 1] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int j = X;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
j++;
}
newLocation.X = j;
newLocation.Y = Y;
return(true);
}
}
}
break;
case Direction.RIGHT:
{
for (int i = Y; i < Y + size.Height; i++)
{
if (map.MapMatrix[i][X + size.Width] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
int j = X + size.Width;
while (map.MapMatrix[i][j] == (int)PhysicalMap.KindOfArea.PHYSICACOBJECT)
{
j--;
}
newLocation.X = j - size.Width + 1;
newLocation.Y = Y;
return(true);
}
}
}
break;
}
return(result);
}
}
public void OnMove(PhysicalMap map)
{
if (!isDying)
{
if (isMoved)
{
switch (direction)
{
case Player.Direction.UP:
{
if (Y - step > 0)
{
if (!isObjectOnWay(map))
{
Y -= step;
if (currAnimState == AnimState.TURNUP)
{
currAnimState = AnimState.TURNUP1;
}
else
{
if (currAnimState == AnimState.TURNUP1)
{
currAnimState = AnimState.TURNUP2;
}
else
{
currAnimState = AnimState.TURNUP1;
}
}
}
else
{
X = newLocation.X;
Y = newLocation.Y;
}
}
else
{
Y = 0;
}
}
break;
case Player.Direction.DOWN:
{
if ((map.Height > (Y + size.Height + step)))
{
if (!isObjectOnWay(map))
{
Y += step;
if (currAnimState == AnimState.TURNDOWN)
{
currAnimState = AnimState.TURNDOWN1;
}
else
{
if (currAnimState == AnimState.TURNDOWN1)
{
currAnimState = AnimState.TURNDOWN2;
}
else
{
currAnimState = AnimState.TURNDOWN1;
}
}
}
else
{
X = newLocation.X;
Y = newLocation.Y;
}
}
else
{
Y = map.Height - size.Height;
}
}
break;
case Player.Direction.LEFT:
{
if (X - step > 0)
{
if (!isObjectOnWay(map))
{
X -= step;
if (currAnimState == AnimState.TURNLEFT)
{
currAnimState = AnimState.TURNLEFT1;
}
else
{
if (currAnimState == AnimState.TURNLEFT1)
{
currAnimState = AnimState.TURNLEFT2;
}
else
{
currAnimState = AnimState.TURNLEFT1;
}
}
}
else
{
X = newLocation.X;
Y = newLocation.Y;
}
}
else
{
X = 0;
}
}
break;
case Player.Direction.RIGHT:
{
if ((map.Width > (X + size.Width + step)))
{
if (!isObjectOnWay(map))
{
X += step;
if (currAnimState == AnimState.TURNRIGHT)
{
currAnimState = AnimState.TURNRIGHT1;
}
else
{
if (currAnimState == AnimState.TURNRIGHT1)
{
currAnimState = AnimState.TURNRIGHT2;
}
else
{
currAnimState = AnimState.TURNRIGHT1;
}
}
}
else
{
X = newLocation.X;
Y = newLocation.Y;
}
}
else
{
X = map.Width - size.Width;
}
}
break;
}
}
else
{
switch (direction)
{
case Direction.UP:
{
currAnimState = AnimState.TURNUP;
}
break;
case Direction.DOWN:
{
currAnimState = AnimState.TURNDOWN;
}
break;
case Direction.LEFT:
{
currAnimState = AnimState.TURNLEFT;
}
break;
case Direction.RIGHT:
{
currAnimState = AnimState.TURNRIGHT;
}
break;
}
}
}
}
