internal void FillFill(Game game, Vector3IntRef a_, Vector3IntRef b_)
{
int startx = MathCi.MinInt(a_.X, b_.X);
int endx = MathCi.MaxInt(a_.X, b_.X);
int starty = MathCi.MinInt(a_.Y, b_.Y);
int endy = MathCi.MaxInt(a_.Y, b_.Y);
int startz = MathCi.MinInt(a_.Z, b_.Z);
int endz = MathCi.MaxInt(a_.Z, b_.Z);
for (int x = startx; x <= endx; x++)
{
for (int y = starty; y <= endy; y++)
{
for (int z = startz; z <= endz; z++)
{
if (fillarea.Count() > game.fillAreaLimit)
{
ClearFillArea(game);
return;
}
if (!game.IsFillBlock(game.map.GetBlock(x, y, z)))
{
fillarea.Set(x, y, z, game.map.GetBlock(x, y, z));
game.SetBlock(x, y, z, game.d_Data.BlockIdFillArea());
game.RedrawBlock(x, y, z);
}
}
}
}
}
internal Vector3IntRef _tempValue; //outside of the function to prevent regular need for GC
public void Set(Vector3IntRef value)
{
int i = 0;
#if !CITO
unchecked
{
#endif
for (i = 0; i < max; i++)
{
_tempValue = values[i];
if (_tempValue == null)
{
break;
}
if (_tempValue.X == value.X &&
_tempValue.Y == value.Y &&
_tempValue.Z == value.Z)
{
return;
}
}
values[i] = Vector3IntRef.Create(value.X, value.Y, value.Z);
#if !CITO
}
#endif
}
void ApplyLightEmitting(int[] workportionArr, byte[] worklightArr, int[] dataLightRadius)
{
int[] radiusArr = dataLightRadius;
const int portionsize = 16;
const int portionsize3 = portionsize * portionsize * portionsize;
Vector3IntRef p = new Vector3IntRef();
for (int pos = 0; pos < portionsize3; pos++)
{
if (workportionArr[pos] >= 10) //optimization
{
if (radiusArr[workportionArr[pos]] != 0) //optimization
{
if (radiusArr[workportionArr[pos]] > worklightArr[pos])
{
MapUtilCi.PosInt(pos, portionsize, portionsize, p);
int xx = p.X;
int yy = p.Y;
int zz = p.Z;
int l = radiusArr[workportionArr[pos]];
lighttoflood.Push(xx);
lighttoflood.Push(yy);
lighttoflood.Push(zz);
worklightArr[pos] = Game.IntToByte(MathCi.MaxInt(l, worklightArr[pos]));
}
}
}
}
}
internal static Vector3IntRef Create(int x, int y, int z)
{
Vector3IntRef v = new Vector3IntRef();
v.X = x;
v.Y = y;
v.Z = z;
return(v);
}
public static Vector3IntRef[] BlocksAround7(Vector3IntRef pos)
{
Vector3IntRef[] arr = new Vector3IntRef[7];
arr[0] = pos;
arr[1] = Vector3IntRef.Create(pos.X + 1, pos.Y + 0, pos.Z + 0);
arr[2] = Vector3IntRef.Create(pos.X - 1, pos.Y + 0, pos.Z + 0);
arr[3] = Vector3IntRef.Create(pos.X + 0, pos.Y + 1, pos.Z + 0);
arr[4] = Vector3IntRef.Create(pos.X + 0, pos.Y - 1, pos.Z + 0);
arr[5] = Vector3IntRef.Create(pos.X + 0, pos.Y + 0, pos.Z + 1);
arr[6] = Vector3IntRef.Create(pos.X + 0, pos.Y + 0, pos.Z - 1);
return(arr);
}
public int[] GetOnTable(Vector3IntRef[] table, int tableCount, IntRef retCount)
{
int[] ontable = new int[2048];
int ontableCount = 0;
for (int i = 0; i < tableCount; i++)
{
Vector3IntRef v = table[i];
int t = d_Map.GetBlock(v.X, v.Y, v.Z + 1);
ontable[ontableCount++] = t;
}
retCount.value = ontableCount;
return ontable;
}
bool Vector3IntRefArrayContains(Vector3IntRef[] l, int lCount, Vector3IntRef p)
{
for (int i = 0; i < lCount; i++)
{
if (l[i].X == p.X
&& l[i].Y == p.Y
&& l[i].Z == p.Z)
{
return true;
}
}
return false;
}
bool Vector3IntRefArrayContains(Vector3IntRef[] l, int lCount, Vector3IntRef p)
{
for (int i = 0; i < lCount; i++)
{
if (l[i].X == p.X &&
l[i].Y == p.Y &&
l[i].Z == p.Z)
{
return(true);
}
}
return(false);
}
public int[] GetOnTable(Vector3IntRef[] table, int tableCount, IntRef retCount)
{
int[] ontable = new int[2048];
int ontableCount = 0;
for (int i = 0; i < tableCount; i++)
{
Vector3IntRef v = table[i];
int t = d_Map.GetBlock(v.X, v.Y, v.Z + 1);
ontable[ontableCount++] = t;
}
retCount.value = ontableCount;
return(ontable);
}
public Vector3IntRef[] GetTable(int posx, int posy, int posz, IntRef retCount)
{
Vector3IntRef[] l = new Vector3IntRef[2048];
int lCount = 0;
Vector3IntRef[] todo = new Vector3IntRef[2048];
int todoCount = 0;
todo[todoCount++] = Vector3IntRef.Create(posx, posy, posz);
for (; ;)
{
if (todoCount == 0 || lCount >= maxcraftingtablesize)
{
break;
}
Vector3IntRef p = todo[todoCount - 1];
todoCount--;
if (Vector3IntRefArrayContains(l, lCount, p))
{
continue;
}
l[lCount++] = p;
Vector3IntRef a = Vector3IntRef.Create(p.X + 1, p.Y, p.Z);
if (d_Map.GetBlock(a.X, a.Y, a.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = a;
}
Vector3IntRef b = Vector3IntRef.Create(p.X - 1, p.Y, p.Z);
if (d_Map.GetBlock(b.X, b.Y, b.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = b;
}
Vector3IntRef c = Vector3IntRef.Create(p.X, p.Y + 1, p.Z);
if (d_Map.GetBlock(c.X, c.Y, c.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = c;
}
Vector3IntRef d = Vector3IntRef.Create(p.X, p.Y - 1, p.Z);
if (d_Map.GetBlock(d.X, d.Y, d.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = d;
}
}
retCount.value = lCount;
return(l);
}
public Vector3IntRef[] GetTable(int posx, int posy, int posz, IntRef retCount)
{
Vector3IntRef[] l = new Vector3IntRef[2048];
int lCount = 0;
Vector3IntRef[] todo = new Vector3IntRef[2048];
int todoCount = 0;
todo[todoCount++] = Vector3IntRef.Create(posx, posy, posz);
for (; ; )
{
if (todoCount == 0 || lCount >= maxcraftingtablesize)
{
break;
}
Vector3IntRef p = todo[todoCount - 1];
todoCount--;
if (Vector3IntRefArrayContains(l, lCount, p))
{
continue;
}
l[lCount++] = p;
Vector3IntRef a = Vector3IntRef.Create(p.X + 1, p.Y, p.Z);
if (d_Map.GetBlock(a.X, a.Y, a.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = a;
}
Vector3IntRef b = Vector3IntRef.Create(p.X - 1, p.Y, p.Z);
if (d_Map.GetBlock(b.X, b.Y, b.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = b;
}
Vector3IntRef c = Vector3IntRef.Create(p.X, p.Y + 1, p.Z);
if (d_Map.GetBlock(c.X, c.Y, c.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = c;
}
Vector3IntRef d = Vector3IntRef.Create(p.X, p.Y - 1, p.Z);
if (d_Map.GetBlock(d.X, d.Y, d.Z) == d_Data.BlockIdCraftingTable())
{
todo[todoCount++] = d;
}
}
retCount.value = lCount;
return l;
}
public void Set(Vector3IntRef value)
{
int i = 0;
for (i = 0; i < max; i++)
{
if (values[i] == null)
{
break;
}
if (values[i].X == value.X &&
values[i].Y == value.Y &&
values[i].Z == value.Z)
{
return;
}
}
values[i] = Vector3IntRef.Create(value.X, value.Y, value.Z);
}
public static Vector3IntRef NextTile_(TileExitDirection direction, int currentTileX, int currentTileY, int currentTileZ)
{
switch (direction)
{
case TileExitDirection.Left:
return(Vector3IntRef.Create(currentTileX - 1, currentTileY, currentTileZ));
case TileExitDirection.Right:
return(Vector3IntRef.Create(currentTileX + 1, currentTileY, currentTileZ));
case TileExitDirection.Up:
return(Vector3IntRef.Create(currentTileX, currentTileY - 1, currentTileZ));
case TileExitDirection.Down:
return(Vector3IntRef.Create(currentTileX, currentTileY + 1, currentTileZ));
default:
return(null);
}
}
public void DrawBlockInfo(Game game)
{
if (!game.drawblockinfo)
{
return;
}
int x = game.SelectedBlockPositionX;
int y = game.SelectedBlockPositionZ;
int z = game.SelectedBlockPositionY;
//string info = "None";
if (!game.map.IsValidPos(x, y, z))
{
return;
}
int blocktype = game.map.GetBlock(x, y, z);
if (!game.IsValid(blocktype))
{
return;
}
game.currentAttackedBlock = Vector3IntRef.Create(x, y, z);
DrawEnemyHealthBlock(game);
}
public void Start()
{
values = new Vector3IntRef[max];
}
public ModUnloadRendererChunks()
{
unloadxyztemp = new Vector3IntRef();
}
public void Start()
{
values = new Vector3IntRef[max];
}
public void UpdateTerrain()
{
if (!terrainRendererStarted)
{
//Start() not called yet.
return;
}
if (!(game.lastplacedblockX == -1 && game.lastplacedblockY == -1 && game.lastplacedblockZ == -1))
{
HashSetVector3IntRef ChunksToRedraw = new HashSetVector3IntRef();
Vector3IntRef[] around = BlocksAround7(Vector3IntRef.Create(game.lastplacedblockX, game.lastplacedblockY, game.lastplacedblockZ));
for (int i = 0; i < 7; i++)
{
Vector3IntRef a = around[i];
ChunksToRedraw.Set(Vector3IntRef.Create(a.X / chunksize, a.Y / chunksize, a.Z / chunksize));
}
for (int i = 0; i < ChunksToRedraw.max; i++)
{
if (ChunksToRedraw.values[i] == null)
{
break;
}
int[] c = new int[3];
int xx = ChunksToRedraw.values[i].X;
int yy = ChunksToRedraw.values[i].Y;
int zz = ChunksToRedraw.values[i].Z;
if (xx >= 0 && yy >= 0 && zz >= 0 &&
xx < game.map.MapSizeX / chunksize && yy < game.map.MapSizeY / chunksize && zz < game.map.MapSizeZ / chunksize)
{
Chunk chunk = game.map.chunks[Index3d(xx, yy, zz, mapsizexchunks(), mapsizeychunks())];
if (chunk == null || chunk.rendered == null)
{
continue;
}
if (chunk.rendered.dirty)
{
RedrawChunk(xx, yy, zz);
}
}
}
game.lastplacedblockX = -1;
game.lastplacedblockY = -1;
game.lastplacedblockZ = -1;
}
int updated = 0;
for (; ;)
{
NearestDirty(tempnearestpos);
if (tempnearestpos[0] == -1 && tempnearestpos[1] == -1 && tempnearestpos[2] == -1)
{
break;
}
RedrawChunk(tempnearestpos[0], tempnearestpos[1], tempnearestpos[2]);
//if (updated++ >= 1)
{
break;
}
//if (framestopwatch.ElapsedMilliseconds > 5)
//{
// break;
//}
}
}
internal void NextBullet(Game game, int bulletsshot)
{
float one = 1;
bool left = game.mouseLeft;
bool middle = game.mouseMiddle;
bool right = game.mouseRight;
bool IsNextShot = bulletsshot != 0;
if (!game.leftpressedpicking)
{
if (game.mouseleftclick)
{
game.leftpressedpicking = true;
}
else
{
left = false;
}
}
else
{
if (game.mouseleftdeclick)
{
game.leftpressedpicking = false;
left = false;
}
}
if (!left)
{
game.currentAttackedBlock = null;
}
Packet_Item item = game.d_Inventory.RightHand[game.ActiveMaterial];
bool ispistol = (item != null && game.blocktypes[item.BlockId].IsPistol);
bool ispistolshoot = ispistol && left;
bool isgrenade = ispistol && game.blocktypes[item.BlockId].PistolType == Packet_PistolTypeEnum.Grenade;
if (ispistol && isgrenade)
{
ispistolshoot = game.mouseleftdeclick;
}
//grenade cooking - TODO: fix instant explosion when closing ESC menu
if (game.mouseleftclick)
{
game.grenadecookingstartMilliseconds = game.platform.TimeMillisecondsFromStart();
if (ispistol && isgrenade)
{
if (game.blocktypes[item.BlockId].Sounds.ShootCount > 0)
{
game.AudioPlay(game.platform.StringFormat("{0}.ogg", game.blocktypes[item.BlockId].Sounds.Shoot[0]));
}
}
}
float wait = ((one * (game.platform.TimeMillisecondsFromStart() - game.grenadecookingstartMilliseconds)) / 1000);
if (isgrenade && left)
{
if (wait >= game.grenadetime && isgrenade && game.grenadecookingstartMilliseconds != 0)
{
ispistolshoot = true;
game.mouseleftdeclick = true;
}
else
{
return;
}
}
else
{
game.grenadecookingstartMilliseconds = 0;
}
if (ispistol && game.mouserightclick && (game.platform.TimeMillisecondsFromStart() - game.lastironsightschangeMilliseconds) >= 500)
{
game.IronSights = !game.IronSights;
game.lastironsightschangeMilliseconds = game.platform.TimeMillisecondsFromStart();
}
IntRef pick2count = new IntRef();
Line3D pick = new Line3D();
GetPickingLine(game, pick, ispistolshoot);
BlockPosSide[] pick2 = game.Pick(game.s, pick, pick2count);
if (left)
{
game.handSetAttackDestroy = true;
}
else if (right)
{
game.handSetAttackBuild = true;
}
if (game.overheadcamera && pick2count.value > 0 && left)
{
//if not picked any object, and mouse button is pressed, then walk to destination.
if (game.Follow == null)
{
//Only walk to destination when not following someone
game.playerdestination = Vector3Ref.Create(pick2[0].blockPos[0], pick2[0].blockPos[1] + 1, pick2[0].blockPos[2]);
}
}
bool pickdistanceok = (pick2count.value > 0); //&& (!ispistol);
if (pickdistanceok)
{
if (game.Dist(pick2[0].blockPos[0] + one / 2, pick2[0].blockPos[1] + one / 2, pick2[0].blockPos[2] + one / 2,
pick.Start[0], pick.Start[1], pick.Start[2]) > CurrentPickDistance(game))
{
pickdistanceok = false;
}
}
bool playertileempty = game.IsTileEmptyForPhysics(
game.platform.FloatToInt(game.player.position.x),
game.platform.FloatToInt(game.player.position.z),
game.platform.FloatToInt(game.player.position.y + (one / 2)));
bool playertileemptyclose = game.IsTileEmptyForPhysicsClose(
game.platform.FloatToInt(game.player.position.x),
game.platform.FloatToInt(game.player.position.z),
game.platform.FloatToInt(game.player.position.y + (one / 2)));
BlockPosSide pick0 = new BlockPosSide();
if (pick2count.value > 0 &&
((pickdistanceok && (playertileempty || (playertileemptyclose))) ||
game.overheadcamera)
)
{
game.SelectedBlockPositionX = game.platform.FloatToInt(pick2[0].Current()[0]);
game.SelectedBlockPositionY = game.platform.FloatToInt(pick2[0].Current()[1]);
game.SelectedBlockPositionZ = game.platform.FloatToInt(pick2[0].Current()[2]);
pick0 = pick2[0];
}
else
{
game.SelectedBlockPositionX = -1;
game.SelectedBlockPositionY = -1;
game.SelectedBlockPositionZ = -1;
pick0.blockPos = new float[3];
pick0.blockPos[0] = -1;
pick0.blockPos[1] = -1;
pick0.blockPos[2] = -1;
}
PickEntity(game, pick, pick2, pick2count);
if (game.cameratype == CameraType.Fpp || game.cameratype == CameraType.Tpp)
{
int ntileX = game.platform.FloatToInt(pick0.Current()[0]);
int ntileY = game.platform.FloatToInt(pick0.Current()[1]);
int ntileZ = game.platform.FloatToInt(pick0.Current()[2]);
if (game.IsUsableBlock(game.map.GetBlock(ntileX, ntileZ, ntileY)))
{
game.currentAttackedBlock = Vector3IntRef.Create(ntileX, ntileZ, ntileY);
}
}
if (game.GetFreeMouse())
{
if (pick2count.value > 0)
{
OnPick_(pick0);
}
return;
}
if ((one * (game.platform.TimeMillisecondsFromStart() - lastbuildMilliseconds) / 1000) >= BuildDelay(game) ||
IsNextShot)
{
if (left && game.d_Inventory.RightHand[game.ActiveMaterial] == null)
{
game.SendPacketClient(ClientPackets.MonsterHit(game.platform.FloatToInt(2 + game.rnd.NextFloat() * 4)));
}
if (left && !fastclicking)
{
//todo animation
fastclicking = false;
}
if ((left || right || middle) && (!isgrenade))
{
lastbuildMilliseconds = game.platform.TimeMillisecondsFromStart();
}
if (isgrenade && game.mouseleftdeclick)
{
lastbuildMilliseconds = game.platform.TimeMillisecondsFromStart();
}
if (game.reloadstartMilliseconds != 0)
{
PickingEnd(left, right, middle, ispistol);
return;
}
if (ispistolshoot)
{
if ((!(game.LoadedAmmo[item.BlockId] > 0)) ||
(!(game.TotalAmmo[item.BlockId] > 0)))
{
game.AudioPlay("Dry Fire Gun-SoundBible.com-2053652037.ogg");
PickingEnd(left, right, middle, ispistol);
return;
}
}
if (ispistolshoot)
{
float toX = pick.End[0];
float toY = pick.End[1];
float toZ = pick.End[2];
if (pick2count.value > 0)
{
toX = pick2[0].blockPos[0];
toY = pick2[0].blockPos[1];
toZ = pick2[0].blockPos[2];
}
Packet_ClientShot shot = new Packet_ClientShot();
shot.FromX = game.SerializeFloat(pick.Start[0]);
shot.FromY = game.SerializeFloat(pick.Start[1]);
shot.FromZ = game.SerializeFloat(pick.Start[2]);
shot.ToX = game.SerializeFloat(toX);
shot.ToY = game.SerializeFloat(toY);
shot.ToZ = game.SerializeFloat(toZ);
shot.HitPlayer = -1;
for (int i = 0; i < game.entitiesCount; i++)
{
if (game.entities[i] == null)
{
continue;
}
if (game.entities[i].drawModel == null)
{
continue;
}
Entity p_ = game.entities[i];
if (p_.networkPosition == null)
{
continue;
}
if (!p_.networkPosition.PositionLoaded)
{
continue;
}
float feetposX = p_.position.x;
float feetposY = p_.position.y;
float feetposZ = p_.position.z;
//var p = PlayerPositionSpawn;
Box3D bodybox = new Box3D();
float headsize = (p_.drawModel.ModelHeight - p_.drawModel.eyeHeight) * 2; //0.4f;
float h = p_.drawModel.ModelHeight - headsize;
float r = one * 35 / 100;
bodybox.AddPoint(feetposX - r, feetposY + 0, feetposZ - r);
bodybox.AddPoint(feetposX - r, feetposY + 0, feetposZ + r);
bodybox.AddPoint(feetposX + r, feetposY + 0, feetposZ - r);
bodybox.AddPoint(feetposX + r, feetposY + 0, feetposZ + r);
bodybox.AddPoint(feetposX - r, feetposY + h, feetposZ - r);
bodybox.AddPoint(feetposX - r, feetposY + h, feetposZ + r);
bodybox.AddPoint(feetposX + r, feetposY + h, feetposZ - r);
bodybox.AddPoint(feetposX + r, feetposY + h, feetposZ + r);
Box3D headbox = new Box3D();
headbox.AddPoint(feetposX - r, feetposY + h, feetposZ - r);
headbox.AddPoint(feetposX - r, feetposY + h, feetposZ + r);
headbox.AddPoint(feetposX + r, feetposY + h, feetposZ - r);
headbox.AddPoint(feetposX + r, feetposY + h, feetposZ + r);
headbox.AddPoint(feetposX - r, feetposY + h + headsize, feetposZ - r);
headbox.AddPoint(feetposX - r, feetposY + h + headsize, feetposZ + r);
headbox.AddPoint(feetposX + r, feetposY + h + headsize, feetposZ - r);
headbox.AddPoint(feetposX + r, feetposY + h + headsize, feetposZ + r);
float[] p;
float localeyeposX = game.EyesPosX();
float localeyeposY = game.EyesPosY();
float localeyeposZ = game.EyesPosZ();
p = Intersection.CheckLineBoxExact(pick, headbox);
if (p != null)
{
//do not allow to shoot through terrain
if (pick2count.value == 0 || (game.Dist(pick2[0].blockPos[0], pick2[0].blockPos[1], pick2[0].blockPos[2], localeyeposX, localeyeposY, localeyeposZ)
> game.Dist(p[0], p[1], p[2], localeyeposX, localeyeposY, localeyeposZ)))
{
if (!isgrenade)
{
Entity entity = new Entity();
Sprite sprite = new Sprite();
sprite.positionX = p[0];
sprite.positionY = p[1];
sprite.positionZ = p[2];
sprite.image = "blood.png";
entity.sprite = sprite;
entity.expires = Expires.Create(one * 2 / 10);
game.EntityAddLocal(entity);
}
shot.HitPlayer = i;
shot.IsHitHead = 1;
}
}
else
{
p = Intersection.CheckLineBoxExact(pick, bodybox);
if (p != null)
{
//do not allow to shoot through terrain
if (pick2count.value == 0 || (game.Dist(pick2[0].blockPos[0], pick2[0].blockPos[1], pick2[0].blockPos[2], localeyeposX, localeyeposY, localeyeposZ)
> game.Dist(p[0], p[1], p[2], localeyeposX, localeyeposY, localeyeposZ)))
{
if (!isgrenade)
{
Entity entity = new Entity();
Sprite sprite = new Sprite();
sprite.positionX = p[0];
sprite.positionY = p[1];
sprite.positionZ = p[2];
sprite.image = "blood.png";
entity.sprite = sprite;
entity.expires = Expires.Create(one * 2 / 10);
game.EntityAddLocal(entity);
}
shot.HitPlayer = i;
shot.IsHitHead = 0;
}
}
}
}
shot.WeaponBlock = item.BlockId;
game.LoadedAmmo[item.BlockId] = game.LoadedAmmo[item.BlockId] - 1;
game.TotalAmmo[item.BlockId] = game.TotalAmmo[item.BlockId] - 1;
float projectilespeed = game.DeserializeFloat(game.blocktypes[item.BlockId].ProjectileSpeedFloat);
if (projectilespeed == 0)
{
{
Entity entity = game.CreateBulletEntity(
pick.Start[0], pick.Start[1], pick.Start[2],
toX, toY, toZ, 150);
game.EntityAddLocal(entity);
}
}
else
{
float vX = toX - pick.Start[0];
float vY = toY - pick.Start[1];
float vZ = toZ - pick.Start[2];
float vLength = game.Length(vX, vY, vZ);
vX /= vLength;
vY /= vLength;
vZ /= vLength;
vX *= projectilespeed;
vY *= projectilespeed;
vZ *= projectilespeed;
shot.ExplodesAfter = game.SerializeFloat(game.grenadetime - wait);
{
Entity grenadeEntity = new Entity();
Sprite sprite = new Sprite();
sprite.image = "ChemicalGreen.png";
sprite.size = 14;
sprite.animationcount = 0;
sprite.positionX = pick.Start[0];
sprite.positionY = pick.Start[1];
sprite.positionZ = pick.Start[2];
grenadeEntity.sprite = sprite;
Grenade_ projectile = new Grenade_();
projectile.velocityX = vX;
projectile.velocityY = vY;
projectile.velocityZ = vZ;
projectile.block = item.BlockId;
projectile.sourcePlayer = game.LocalPlayerId;
grenadeEntity.expires = Expires.Create(game.grenadetime - wait);
grenadeEntity.grenade = projectile;
game.EntityAddLocal(grenadeEntity);
}
}
Packet_Client packet = new Packet_Client();
packet.Id = Packet_ClientIdEnum.Shot;
packet.Shot = shot;
game.SendPacketClient(packet);
if (game.blocktypes[item.BlockId].Sounds.ShootEndCount > 0)
{
game.pistolcycle = game.rnd.Next() % game.blocktypes[item.BlockId].Sounds.ShootEndCount;
game.AudioPlay(game.platform.StringFormat("{0}.ogg", game.blocktypes[item.BlockId].Sounds.ShootEnd[game.pistolcycle]));
}
bulletsshot++;
if (bulletsshot < game.DeserializeFloat(game.blocktypes[item.BlockId].BulletsPerShotFloat))
{
NextBullet(game, bulletsshot);
}
//recoil
game.player.position.rotx -= game.rnd.NextFloat() * game.CurrentRecoil();
game.player.position.roty += game.rnd.NextFloat() * game.CurrentRecoil() * 2 - game.CurrentRecoil();
PickingEnd(left, right, middle, ispistol);
return;
}
if (ispistol && right)
{
PickingEnd(left, right, middle, ispistol);
return;
}
if (pick2count.value > 0)
{
if (middle)
{
int newtileX = game.platform.FloatToInt(pick0.Current()[0]);
int newtileY = game.platform.FloatToInt(pick0.Current()[1]);
int newtileZ = game.platform.FloatToInt(pick0.Current()[2]);
if (game.map.IsValidPos(newtileX, newtileZ, newtileY))
{
int clonesource = game.map.GetBlock(newtileX, newtileZ, newtileY);
int clonesource2 = game.d_Data.WhenPlayerPlacesGetsConvertedTo()[clonesource];
bool gotoDone = false;
//find this block in another right hand.
for (int i = 0; i < 10; i++)
{
if (game.d_Inventory.RightHand[i] != null &&
game.d_Inventory.RightHand[i].ItemClass == Packet_ItemClassEnum.Block &&
game.d_Inventory.RightHand[i].BlockId == clonesource2)
{
game.ActiveMaterial = i;
gotoDone = true;
}
}
if (!gotoDone)
{
IntRef freehand = game.d_InventoryUtil.FreeHand(game.ActiveMaterial);
//find this block in inventory.
for (int i = 0; i < game.d_Inventory.ItemsCount; i++)
{
Packet_PositionItem k = game.d_Inventory.Items[i];
if (k == null)
{
continue;
}
if (k.Value_.ItemClass == Packet_ItemClassEnum.Block &&
k.Value_.BlockId == clonesource2)
{
//free hand
if (freehand != null)
{
game.WearItem(
game.InventoryPositionMainArea(k.X, k.Y),
game.InventoryPositionMaterialSelector(freehand.value));
break;
}
//try to replace current slot
if (game.d_Inventory.RightHand[game.ActiveMaterial] != null &&
game.d_Inventory.RightHand[game.ActiveMaterial].ItemClass == Packet_ItemClassEnum.Block)
{
game.MoveToInventory(
game.InventoryPositionMaterialSelector(game.ActiveMaterial));
game.WearItem(
game.InventoryPositionMainArea(k.X, k.Y),
game.InventoryPositionMaterialSelector(game.ActiveMaterial));
}
}
}
}
string[] sound = game.d_Data.CloneSound()[clonesource];
if (sound != null) // && sound.Length > 0)
{
game.AudioPlay(sound[0]); //todo sound cycle
}
}
}
if (left || right)
{
BlockPosSide tile = pick0;
int newtileX;
int newtileY;
int newtileZ;
if (right)
{
newtileX = game.platform.FloatToInt(tile.Translated()[0]);
newtileY = game.platform.FloatToInt(tile.Translated()[1]);
newtileZ = game.platform.FloatToInt(tile.Translated()[2]);
}
else
{
newtileX = game.platform.FloatToInt(tile.Current()[0]);
newtileY = game.platform.FloatToInt(tile.Current()[1]);
newtileZ = game.platform.FloatToInt(tile.Current()[2]);
}
if (game.map.IsValidPos(newtileX, newtileZ, newtileY))
{
//Console.WriteLine(". newtile:" + newtile + " type: " + d_Map.GetBlock(newtileX, newtileZ, newtileY));
if (!(pick0.blockPos[0] == -1 &&
pick0.blockPos[1] == -1 &&
pick0.blockPos[2] == -1))
{
int blocktype;
if (left)
{
blocktype = game.map.GetBlock(newtileX, newtileZ, newtileY);
}
else
{
blocktype = ((game.BlockInHand() == null) ? 1 : game.BlockInHand().value);
}
if (left && blocktype == game.d_Data.BlockIdAdminium())
{
PickingEnd(left, right, middle, ispistol);
return;
}
string[] sound = left ? game.d_Data.BreakSound()[blocktype] : game.d_Data.BuildSound()[blocktype];
if (sound != null) // && sound.Length > 0)
{
game.AudioPlay(sound[0]); //todo sound cycle
}
}
//normal attack
if (!right)
{
//attack
int posx = newtileX;
int posy = newtileZ;
int posz = newtileY;
game.currentAttackedBlock = Vector3IntRef.Create(posx, posy, posz);
if (!game.blockHealth.ContainsKey(posx, posy, posz))
{
game.blockHealth.Set(posx, posy, posz, game.GetCurrentBlockHealth(posx, posy, posz));
}
game.blockHealth.Set(posx, posy, posz, game.blockHealth.Get(posx, posy, posz) - game.WeaponAttackStrength());
float health = game.GetCurrentBlockHealth(posx, posy, posz);
if (health <= 0)
{
if (game.currentAttackedBlock != null)
{
game.blockHealth.Remove(posx, posy, posz);
}
game.currentAttackedBlock = null;
OnPick(game, game.platform.FloatToInt(newtileX), game.platform.FloatToInt(newtileZ), game.platform.FloatToInt(newtileY),
game.platform.FloatToInt(tile.Current()[0]), game.platform.FloatToInt(tile.Current()[2]), game.platform.FloatToInt(tile.Current()[1]),
tile.collisionPos,
right);
}
PickingEnd(left, right, middle, ispistol);
return;
}
if (!right)
{
game.particleEffectBlockBreak.StartParticleEffect(newtileX, newtileY, newtileZ);//must be before deletion - gets ground type.
}
if (!game.map.IsValidPos(newtileX, newtileZ, newtileY))
{
game.platform.ThrowException("Error in picking - NextBullet()");
}
OnPick(game, game.platform.FloatToInt(newtileX), game.platform.FloatToInt(newtileZ), game.platform.FloatToInt(newtileY),
game.platform.FloatToInt(tile.Current()[0]), game.platform.FloatToInt(tile.Current()[2]), game.platform.FloatToInt(tile.Current()[1]),
tile.collisionPos,
right);
//network.SendSetBlock(new Vector3((int)newtile.X, (int)newtile.Z, (int)newtile.Y),
// right ? BlockSetMode.Create : BlockSetMode.Destroy, (byte)MaterialSlots[activematerial]);
}
}
}
}
PickingEnd(left, right, middle, ispistol);
}
internal Vector3Ref GrenadeBounce(Game game, Vector3Ref oldposition, Vector3Ref newposition, Vector3Ref velocity, float dt)
{
bool ismoving = velocity.Length() > 100 * dt;
float modelheight = walldistance;
oldposition.Y += walldistance;
newposition.Y += walldistance;
//Math.Floor() is needed because casting negative values to integer is not floor.
Vector3IntRef oldpositioni = Vector3IntRef.Create(game.MathFloor(oldposition.X),
game.MathFloor(oldposition.Z),
game.MathFloor(oldposition.Y));
float playerpositionX = newposition.X;
float playerpositionY = newposition.Y;
float playerpositionZ = newposition.Z;
//left
{
float qnewpositionX = newposition.X;
float qnewpositionY = newposition.Y;
float qnewpositionZ = newposition.Z + walldistance;
bool newempty = game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY)) &&
game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY) + 1);
if (newposition.Z - oldposition.Z > 0)
{
if (!newempty)
{
velocity.Z = -velocity.Z;
velocity.X *= bouncespeedmultiply;
velocity.Y *= bouncespeedmultiply;
velocity.Z *= bouncespeedmultiply;
if (ismoving)
{
game.AudioPlayAt("grenadebounce.ogg", newposition.X, newposition.Y, newposition.Z);
}
//playerposition.Z = oldposition.Z - newposition.Z;
}
}
}
//front
{
float qnewpositionX = newposition.X + walldistance;
float qnewpositionY = newposition.Y;
float qnewpositionZ = newposition.Z;
bool newempty = game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY)) &&
game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY) + 1);
if (newposition.X - oldposition.X > 0)
{
if (!newempty)
{
velocity.X = -velocity.X;
velocity.X *= bouncespeedmultiply;
velocity.Y *= bouncespeedmultiply;
velocity.Z *= bouncespeedmultiply;
if (ismoving)
{
game.AudioPlayAt("grenadebounce.ogg", newposition.X, newposition.Y, newposition.Z);
}
//playerposition.X = oldposition.X - newposition.X;
}
}
}
//top
{
float qnewpositionX = newposition.X;
float qnewpositionY = newposition.Y - walldistance;
float qnewpositionZ = newposition.Z;
int x = game.MathFloor(qnewpositionX);
int y = game.MathFloor(qnewpositionZ);
int z = game.MathFloor(qnewpositionY);
float a_ = walldistance;
bool newfull = (!game.IsTileEmptyForPhysics(x, y, z)) ||
(qnewpositionX - game.MathFloor(qnewpositionX) <= a_ && (!game.IsTileEmptyForPhysics(x - 1, y, z)) && (game.IsTileEmptyForPhysics(x - 1, y, z + 1))) ||
(qnewpositionX - game.MathFloor(qnewpositionX) >= (1 - a_) && (!game.IsTileEmptyForPhysics(x + 1, y, z)) && (game.IsTileEmptyForPhysics(x + 1, y, z + 1))) ||
(qnewpositionZ - game.MathFloor(qnewpositionZ) <= a_ && (!game.IsTileEmptyForPhysics(x, y - 1, z)) && (game.IsTileEmptyForPhysics(x, y - 1, z + 1))) ||
(qnewpositionZ - game.MathFloor(qnewpositionZ) >= (1 - a_) && (!game.IsTileEmptyForPhysics(x, y + 1, z)) && (game.IsTileEmptyForPhysics(x, y + 1, z + 1)));
if (newposition.Y - oldposition.Y < 0)
{
if (newfull)
{
velocity.Y = -velocity.Y;
velocity.X *= bouncespeedmultiply;
velocity.Y *= bouncespeedmultiply;
velocity.Z *= bouncespeedmultiply;
if (ismoving)
{
game.AudioPlayAt("grenadebounce.ogg", newposition.X, newposition.Y, newposition.Z);
}
//playerposition.Y = oldposition.Y - newposition.Y;
}
}
}
//right
{
float qnewpositionX = newposition.X;
float qnewpositionY = newposition.Y;
float qnewpositionZ = newposition.Z - walldistance;
bool newempty = game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY)) &&
game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY) + 1);
if (newposition.Z - oldposition.Z < 0)
{
if (!newempty)
{
velocity.Z = -velocity.Z;
velocity.X *= bouncespeedmultiply;
velocity.Y *= bouncespeedmultiply;
velocity.Z *= bouncespeedmultiply;
if (ismoving)
{
game.AudioPlayAt("grenadebounce.ogg", newposition.X, newposition.Y, newposition.Z);
}
//playerposition.Z = oldposition.Z - newposition.Z;
}
}
}
//back
{
float qnewpositionX = newposition.X - walldistance;
float qnewpositionY = newposition.Y;
float qnewpositionZ = newposition.Z;
bool newempty = game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY)) &&
game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY) + 1);
if (newposition.X - oldposition.X < 0)
{
if (!newempty)
{
velocity.X = -velocity.X;
velocity.X *= bouncespeedmultiply;
velocity.Y *= bouncespeedmultiply;
velocity.Z *= bouncespeedmultiply;
if (ismoving)
{
game.AudioPlayAt("grenadebounce.ogg", newposition.X, newposition.Y, newposition.Z);
}
//playerposition.X = oldposition.X - newposition.X;
}
}
}
//bottom
{
float qnewpositionX = newposition.X;
float qnewpositionY = newposition.Y + modelheight;
float qnewpositionZ = newposition.Z;
bool newempty = game.IsTileEmptyForPhysics(game.MathFloor(qnewpositionX), game.MathFloor(qnewpositionZ), game.MathFloor(qnewpositionY));
if (newposition.Y - oldposition.Y > 0)
{
if (!newempty)
{
velocity.Y = -velocity.Y;
velocity.X *= bouncespeedmultiply;
velocity.Y *= bouncespeedmultiply;
velocity.Z *= bouncespeedmultiply;
if (ismoving)
{
game.AudioPlayAt("grenadebounce.ogg", newposition.X, newposition.Y, newposition.Z);
}
//playerposition.Y = oldposition.Y - newposition.Y;
}
}
}
//ok:
playerpositionY -= walldistance;
return(Vector3Ref.Create(playerpositionX, playerpositionY, playerpositionZ));
}
internal void RailOnNewFrame(Game game, float dt)
{
if (localMinecart == null)
{
localMinecart = new Entity();
localMinecart.minecart = new Minecart();
game.EntityAddLocal(localMinecart);
}
localMinecart.minecart.enabled = railriding;
if (railriding)
{
Minecart m = localMinecart.minecart;
m.positionX = game.player.position.x;
m.positionY = game.player.position.y;
m.positionZ = game.player.position.z;
m.direction = currentdirection;
m.lastdirection = lastdirection;
m.progress = currentrailblockprogress;
}
game.localplayeranimationhint.InVehicle = railriding;
game.localplayeranimationhint.DrawFixX = 0;
game.localplayeranimationhint.DrawFixY = railriding ? (-one * 7 / 10) : 0;
game.localplayeranimationhint.DrawFixZ = 0;
bool turnright = game.keyboardState[game.GetKey(GlKeys.D)];
bool turnleft = game.keyboardState[game.GetKey(GlKeys.A)];
RailSound(game);
if (railriding)
{
game.controls.SetFreemove(FreemoveLevelEnum.Freemove);
game.enable_move = false;
Vector3Ref railPos = CurrentRailPos(game);
game.player.position.x = railPos.X;
game.player.position.y = railPos.Y;
game.player.position.z = railPos.Z;
currentrailblockprogress += currentvehiclespeed * dt;
if (currentrailblockprogress >= 1)
{
lastdirection = currentdirection;
currentrailblockprogress = 0;
TileEnterData newenter = new TileEnterData();
Vector3IntRef nexttile = NextTile(currentdirection, currentrailblockX, currentrailblockY, currentrailblockZ);
newenter.BlockPositionX = nexttile.X;
newenter.BlockPositionY = nexttile.Y;
newenter.BlockPositionZ = nexttile.Z;
//slope
if (GetUpDownMove(game, currentrailblockX, currentrailblockY, currentrailblockZ,
DirectionUtils.ResultEnter(DirectionUtils.ResultExit(currentdirection))) == UpDown.Up)
{
newenter.BlockPositionZ++;
}
if (GetUpDownMove(game, newenter.BlockPositionX,
newenter.BlockPositionY,
newenter.BlockPositionZ - 1,
DirectionUtils.ResultEnter(DirectionUtils.ResultExit(currentdirection))) == UpDown.Down)
{
newenter.BlockPositionZ--;
}
newenter.EnterDirection = DirectionUtils.ResultEnter(DirectionUtils.ResultExit(currentdirection));
BoolRef newdirFound = new BoolRef();
VehicleDirection12 newdir = BestNewDirection(PossibleRails(game, newenter), turnleft, turnright, newdirFound);
if (!newdirFound.value)
{
//end of rail
currentdirection = DirectionUtils.Reverse(currentdirection);
}
else
{
currentdirection = newdir;
currentrailblockX = game.platform.FloatToInt(newenter.BlockPositionX);
currentrailblockY = game.platform.FloatToInt(newenter.BlockPositionY);
currentrailblockZ = game.platform.FloatToInt(newenter.BlockPositionZ);
}
}
}
if (game.keyboardState[game.GetKey(GlKeys.W)] && game.GuiTyping != TypingState.Typing)
{
currentvehiclespeed += 1 * dt;
}
if (game.keyboardState[game.GetKey(GlKeys.S)] && game.GuiTyping != TypingState.Typing)
{
currentvehiclespeed -= 5 * dt;
}
if (currentvehiclespeed < 0)
{
currentvehiclespeed = 0;
}
//todo fix
//if (viewport.keypressed != null && viewport.keypressed.Key == GlKeys.Q)
if (!wasqpressed && game.keyboardState[game.GetKey(GlKeys.Q)] && game.GuiTyping != TypingState.Typing)
{
Reverse();
}
if (!wasepressed && game.keyboardState[game.GetKey(GlKeys.E)] && !railriding && (game.controls.GetFreemove() == FreemoveLevelEnum.None) && game.GuiTyping != TypingState.Typing)
{
currentrailblockX = game.platform.FloatToInt(game.player.position.x);
currentrailblockY = game.platform.FloatToInt(game.player.position.z);
currentrailblockZ = game.platform.FloatToInt(game.player.position.y) - 1;
if (!game.map.IsValidPos(currentrailblockX, currentrailblockY, currentrailblockZ))
{
ExitVehicle(game);
}
else
{
int railunderplayer = game.d_Data.Rail()[game.map.GetBlock(currentrailblockX, currentrailblockY, currentrailblockZ)];
railriding = true;
originalmodelheight = game.GetCharacterEyesHeight();
game.SetCharacterEyesHeight(minecartheight());
currentvehiclespeed = 0;
if ((railunderplayer & RailDirectionFlags.Horizontal) != 0)
{
currentdirection = VehicleDirection12.HorizontalRight;
}
else if ((railunderplayer & RailDirectionFlags.Vertical) != 0)
{
currentdirection = VehicleDirection12.VerticalUp;
}
else if ((railunderplayer & RailDirectionFlags.UpLeft) != 0)
{
currentdirection = VehicleDirection12.UpLeftUp;
}
else if ((railunderplayer & RailDirectionFlags.UpRight) != 0)
{
currentdirection = VehicleDirection12.UpRightUp;
}
else if ((railunderplayer & RailDirectionFlags.DownLeft) != 0)
{
currentdirection = VehicleDirection12.DownLeftLeft;
}
else if ((railunderplayer & RailDirectionFlags.DownRight) != 0)
{
currentdirection = VehicleDirection12.DownRightRight;
}
else
{
ExitVehicle(game);
}
lastdirection = currentdirection;
}
}
else if (!wasepressed && game.keyboardState[game.GetKey(GlKeys.E)] && railriding && game.GuiTyping != TypingState.Typing)
{
ExitVehicle(game);
game.player.position.y += one * 7 / 10;
}
wasqpressed = game.keyboardState[game.GetKey(GlKeys.Q)] && game.GuiTyping != TypingState.Typing;
wasepressed = game.keyboardState[game.GetKey(GlKeys.E)] && game.GuiTyping != TypingState.Typing;
}
public ServerSystemUnloadUnusedChunks()
{
chunkpos = new Vector3IntRef();
}
public ServerSystemUnloadUnusedChunks()
{
chunkpos = new Vector3IntRef();
}
internal void OnPick(Game game, int blockposX, int blockposY, int blockposZ, int blockposoldX, int blockposoldY, int blockposoldZ, float[] collisionPos, bool right)
{
float xfract = collisionPos[0] - game.MathFloor(collisionPos[0]);
float zfract = collisionPos[2] - game.MathFloor(collisionPos[2]);
int activematerial = game.MaterialSlots_(game.ActiveMaterial);
int railstart = game.d_Data.BlockIdRailstart();
if (activematerial == railstart + RailDirectionFlags.TwoHorizontalVertical
|| activematerial == railstart + RailDirectionFlags.Corners)
{
RailDirection dirnew;
if (activematerial == railstart + RailDirectionFlags.TwoHorizontalVertical)
{
dirnew = PickHorizontalVertical(xfract, zfract);
}
else
{
dirnew = PickCorners(xfract, zfract);
}
int dir = game.d_Data.Rail()[game.map.GetBlock(blockposoldX, blockposoldY, blockposoldZ)];
if (dir != 0)
{
blockposX = blockposoldX;
blockposY = blockposoldY;
blockposZ = blockposoldZ;
}
activematerial = railstart + (dir | DirectionUtils.ToRailDirectionFlags(dirnew));
}
int x = game.platform.FloatToInt(blockposX);
int y = game.platform.FloatToInt(blockposY);
int z = game.platform.FloatToInt(blockposZ);
int mode = right ? Packet_BlockSetModeEnum.Create : Packet_BlockSetModeEnum.Destroy;
{
if (game.IsAnyPlayerInPos(x, y, z) || activematerial == 151) // Compass
{
return;
}
Vector3IntRef v = Vector3IntRef.Create(x, y, z);
Vector3IntRef oldfillstart = fillstart;
Vector3IntRef oldfillend = fillend;
if (mode == Packet_BlockSetModeEnum.Create)
{
if (game.blocktypes[activematerial].IsTool)
{
OnPickUseWithTool(game, blockposX, blockposY, blockposZ);
return;
}
if (activematerial == game.d_Data.BlockIdCuboid())
{
ClearFillArea(game);
if (fillstart != null)
{
Vector3IntRef f = fillstart;
if (!game.IsFillBlock(game.map.GetBlock(f.X, f.Y, f.Z)))
{
fillarea.Set(f.X, f.Y, f.Z, game.map.GetBlock(f.X, f.Y, f.Z));
}
game.SetBlock(f.X, f.Y, f.Z, game.d_Data.BlockIdFillStart());
FillFill(game, v, fillstart);
}
if (!game.IsFillBlock(game.map.GetBlock(v.X, v.Y, v.Z)))
{
fillarea.Set(v.X, v.Y, v.Z, game.map.GetBlock(v.X, v.Y, v.Z));
}
game.SetBlock(v.X, v.Y, v.Z, game.d_Data.BlockIdCuboid());
fillend = v;
game.RedrawBlock(v.X, v.Y, v.Z);
return;
}
if (activematerial == game.d_Data.BlockIdFillStart())
{
ClearFillArea(game);
if (!game.IsFillBlock(game.map.GetBlock(v.X, v.Y, v.Z)))
{
fillarea.Set(v.X, v.Y, v.Z, game.map.GetBlock(v.X, v.Y, v.Z));
}
game.SetBlock(v.X, v.Y, v.Z, game.d_Data.BlockIdFillStart());
fillstart = v;
fillend = null;
game.RedrawBlock(v.X, v.Y, v.Z);
return;
}
if (fillarea.ContainsKey(v.X, v.Y, v.Z))// && fillarea[v])
{
game.SendFillArea(fillstart.X, fillstart.Y, fillstart.Z, fillend.X, fillend.Y, fillend.Z, activematerial);
ClearFillArea(game);
fillstart = null;
fillend = null;
return;
}
}
else
{
if (game.blocktypes[activematerial].IsTool)
{
OnPickUseWithTool(game, blockposX, blockposY, blockposoldZ);
return;
}
//delete fill start
if (fillstart != null && fillstart.X == v.X && fillstart.Y == v.Y && fillstart.Z == v.Z)
{
ClearFillArea(game);
fillstart = null;
fillend = null;
return;
}
//delete fill end
if (fillend != null && fillend.X == v.X && fillend.Y == v.Y && fillend.Z == v.Z)
{
ClearFillArea(game);
fillend = null;
return;
}
}
game.SendSetBlockAndUpdateSpeculative(activematerial, x, y, z, mode);
}
}
public void Set(Vector3IntRef value)
{
int i = 0;
for (i = 0; i < max; i++)
{
if (values[i] == null)
{
break;
}
if (values[i].X == value.X
&& values[i].Y == value.Y
&& values[i].Z == value.Z)
{
return;
}
}
values[i] = Vector3IntRef.Create(value.X, value.Y, value.Z);
}
internal static void PosInt(int index, int sizex, int sizey, Vector3IntRef ret)
{
int x = index % sizex;
int y = (index / sizex) % sizey;
int h = index / (sizex * sizey);
ret.X = x;
ret.Y = y;
ret.Z = h;
}
public ModUnloadRendererChunks()
{
unloadxyztemp = new Vector3IntRef();
}
internal Vector3IntRef _tempValue; //outside of the function to prevent regular need for GC
public void Set(Vector3IntRef value)
{
int i = 0;
#if !CITO
unchecked
{
#endif
for (i = 0; i < max; i++)
{
_tempValue = values[i];
if (_tempValue == null)
{
break;
}
if (_tempValue.X == value.X
&& _tempValue.Y == value.Y
&& _tempValue.Z == value.Z)
{
return;
}
}
values[i] = Vector3IntRef.Create(value.X, value.Y, value.Z);
#if !CITO
}
#endif
}
public static Vector3IntRef[] BlocksAround7(Vector3IntRef pos)
{
Vector3IntRef[] arr = new Vector3IntRef[7];
arr[0] = pos;
arr[1] = Vector3IntRef.Create(pos.X + 1, pos.Y + 0, pos.Z + 0);
arr[2] = Vector3IntRef.Create(pos.X - 1, pos.Y + 0, pos.Z + 0);
arr[3] = Vector3IntRef.Create(pos.X + 0, pos.Y + 1, pos.Z + 0);
arr[4] = Vector3IntRef.Create(pos.X + 0, pos.Y - 1, pos.Z + 0);
arr[5] = Vector3IntRef.Create(pos.X + 0, pos.Y + 0, pos.Z + 1);
arr[6] = Vector3IntRef.Create(pos.X + 0, pos.Y + 0, pos.Z - 1);
return arr;
}
internal static Vector3IntRef Create(int x, int y, int z)
{
Vector3IntRef v = new Vector3IntRef();
v.X = x;
v.Y = y;
v.Z = z;
return v;
}
internal void FillFill(Game game, Vector3IntRef a_, Vector3IntRef b_)
{
int startx = MathCi.MinInt(a_.X, b_.X);
int endx = MathCi.MaxInt(a_.X, b_.X);
int starty = MathCi.MinInt(a_.Y, b_.Y);
int endy = MathCi.MaxInt(a_.Y, b_.Y);
int startz = MathCi.MinInt(a_.Z, b_.Z);
int endz = MathCi.MaxInt(a_.Z, b_.Z);
for (int x = startx; x <= endx; x++)
{
for (int y = starty; y <= endy; y++)
{
for (int z = startz; z <= endz; z++)
{
if (fillarea.Count() > game.fillAreaLimit)
{
ClearFillArea(game);
return;
}
if (!game.IsFillBlock(game.map.GetBlock(x, y, z)))
{
fillarea.Set(x, y, z, game.map.GetBlock(x, y, z));
game.SetBlock(x, y, z, game.d_Data.BlockIdFillArea());
game.RedrawBlock(x, y, z);
}
}
}
}
}
internal void OnPick(Game game, int blockposX, int blockposY, int blockposZ, int blockposoldX, int blockposoldY, int blockposoldZ, float[] collisionPos, bool right)
{
float xfract = collisionPos[0] - game.MathFloor(collisionPos[0]);
float zfract = collisionPos[2] - game.MathFloor(collisionPos[2]);
int activematerial = game.MaterialSlots_(game.ActiveMaterial);
int railstart = game.d_Data.BlockIdRailstart();
if (activematerial == railstart + RailDirectionFlags.TwoHorizontalVertical ||
activematerial == railstart + RailDirectionFlags.Corners)
{
RailDirection dirnew;
if (activematerial == railstart + RailDirectionFlags.TwoHorizontalVertical)
{
dirnew = PickHorizontalVertical(xfract, zfract);
}
else
{
dirnew = PickCorners(xfract, zfract);
}
int dir = game.d_Data.Rail()[game.map.GetBlock(blockposoldX, blockposoldY, blockposoldZ)];
if (dir != 0)
{
blockposX = blockposoldX;
blockposY = blockposoldY;
blockposZ = blockposoldZ;
}
activematerial = railstart + (dir | DirectionUtils.ToRailDirectionFlags(dirnew));
}
int x = game.platform.FloatToInt(blockposX);
int y = game.platform.FloatToInt(blockposY);
int z = game.platform.FloatToInt(blockposZ);
int mode = right ? Packet_BlockSetModeEnum.Create : Packet_BlockSetModeEnum.Destroy;
{
if (game.IsAnyPlayerInPos(x, y, z) || activematerial == 151) // Compass
{
return;
}
Vector3IntRef v = Vector3IntRef.Create(x, y, z);
Vector3IntRef oldfillstart = fillstart;
Vector3IntRef oldfillend = fillend;
if (mode == Packet_BlockSetModeEnum.Create)
{
if (game.blocktypes[activematerial].IsTool)
{
OnPickUseWithTool(game, blockposX, blockposY, blockposZ);
return;
}
if (activematerial == game.d_Data.BlockIdCuboid())
{
ClearFillArea(game);
if (fillstart != null)
{
Vector3IntRef f = fillstart;
if (!game.IsFillBlock(game.map.GetBlock(f.X, f.Y, f.Z)))
{
fillarea.Set(f.X, f.Y, f.Z, game.map.GetBlock(f.X, f.Y, f.Z));
}
game.SetBlock(f.X, f.Y, f.Z, game.d_Data.BlockIdFillStart());
FillFill(game, v, fillstart);
}
if (!game.IsFillBlock(game.map.GetBlock(v.X, v.Y, v.Z)))
{
fillarea.Set(v.X, v.Y, v.Z, game.map.GetBlock(v.X, v.Y, v.Z));
}
game.SetBlock(v.X, v.Y, v.Z, game.d_Data.BlockIdCuboid());
fillend = v;
game.RedrawBlock(v.X, v.Y, v.Z);
return;
}
if (activematerial == game.d_Data.BlockIdFillStart())
{
ClearFillArea(game);
if (!game.IsFillBlock(game.map.GetBlock(v.X, v.Y, v.Z)))
{
fillarea.Set(v.X, v.Y, v.Z, game.map.GetBlock(v.X, v.Y, v.Z));
}
game.SetBlock(v.X, v.Y, v.Z, game.d_Data.BlockIdFillStart());
fillstart = v;
fillend = null;
game.RedrawBlock(v.X, v.Y, v.Z);
return;
}
if (fillarea.ContainsKey(v.X, v.Y, v.Z))// && fillarea[v])
{
game.SendFillArea(fillstart.X, fillstart.Y, fillstart.Z, fillend.X, fillend.Y, fillend.Z, activematerial);
ClearFillArea(game);
fillstart = null;
fillend = null;
return;
}
}
else
{
if (game.blocktypes[activematerial].IsTool)
{
OnPickUseWithTool(game, blockposX, blockposY, blockposoldZ);
return;
}
//delete fill start
if (fillstart != null && fillstart.X == v.X && fillstart.Y == v.Y && fillstart.Z == v.Z)
{
ClearFillArea(game);
fillstart = null;
fillend = null;
return;
}
//delete fill end
if (fillend != null && fillend.X == v.X && fillend.Y == v.Y && fillend.Z == v.Z)
{
ClearFillArea(game);
fillend = null;
return;
}
}
game.SendSetBlockAndUpdateSpeculative(activematerial, x, y, z, mode);
}
}
