public void SetBlockNotMakingDirty(int x, int y, int z, int tileType)
{
ServerChunk chunk = GetChunk(x, y, z);
chunk.data[MapUtilCi.Index3d(x % chunksize, y % chunksize, z % chunksize, chunksize, chunksize)] = (ushort)tileType;
chunk.DirtyForSaving = true;
UpdateColumnHeight(x, y);
}
public override void SetBlock(int x, int y, int z, int tileType)
{
ServerChunk chunk = GetChunk(x, y, z);
chunk.data[MapUtilCi.Index3d(x % chunksize, y % chunksize, z % chunksize, chunksize, chunksize)] = (ushort)tileType;
chunk.LastChange = d_CurrentTime.GetSimulationCurrentFrame();
chunk.DirtyForSaving = true;
UpdateColumnHeight(x, y);
}
public override int GetBlock(int x, int y, int z)
{
ServerChunk chunk = GetChunk(x, y, z);
//return chunk.data[MapUtilCi.Index3d(x % chunksize, y % chunksize, z % chunksize, chunksize, chunksize)];
unchecked
{
return(chunk.data[MapUtilCi.Index3d(moduloChunk(x), moduloChunk(y), moduloChunk(z), chunksize, chunksize)]);
}
}
int GetColumnHeightInChunk(ushort[] chunk, int xx, int yy)
{
int height = chunksize - 1;
for (int i = chunksize - 1; i >= 0; i--)
{
height = i;
if (!Server.IsTransparentForLight(server.BlockTypes[chunk[MapUtilCi.Index3d(xx, yy, i, chunksize, chunksize)]]))
{
break;
}
}
return(height);
}
void RedrawChunk(int x, int y, int z)
{
#if !CITO
unchecked
{
#endif
Chunk c = game.map.chunks[MapUtilCi.Index3d(x, y, z, mapsizexchunks(), mapsizeychunks())];
if (c == null)
{
return;
}
if (c.rendered == null)
{
c.rendered = new RenderedChunk();
}
c.rendered.dirty = false;
chunkupdates++;
GetExtendedChunk(x, y, z);
TerrainRendererRedraw r = new TerrainRendererRedraw();
r.c = c;
VerticesIndicesToLoad[] a = null;
IntRef retCount = new IntRef();
if (!IsSolidChunk(currentChunk, (bufferedChunkSize) * (bufferedChunkSize) * (bufferedChunkSize)))
{
CalculateShadows(x, y, z);
a = game.d_TerrainChunkTesselator.MakeChunk(x, y, z, currentChunk, currentChunkShadows, game.mLightLevels, retCount);
}
r.data = new VerticesIndicesToLoad[retCount.value];
for (int i = 0; i < retCount.value; i++)
{
r.data[i] = VerticesIndicesToLoadClone(a[i]);
}
r.dataCount = retCount.value;
redraw[redrawCount++] = r;
#if !CITO
}
#endif
}
void ChunkUpdate(Server server, Vector3i p, long lastupdate)
{
if (server.config.Monsters)
{
AddMonsters(server, p);
}
ServerChunk chunk = server.d_Map.GetChunk(p.x, p.y, p.z);
for (int xx = 0; xx < Server.chunksize; xx++)
{
for (int yy = 0; yy < Server.chunksize; yy++)
{
for (int zz = 0; zz < Server.chunksize; zz++)
{
int block = chunk.data[MapUtilCi.Index3d(xx, yy, zz, Server.chunksize, Server.chunksize)];
for (int i = 0; i < server.modEventHandlers.blockticks.Count; i++)
{
server.modEventHandlers.blockticks[i](p.x + xx, p.y + yy, p.z + zz);
}
}
}
}
}
public void Update(EntityPosition_ stateplayerposition, Controls move, float dt, BoolRef soundnow, Vector3Ref push, float modelheight)
{
if (game.stopPlayerMove)
{
movedz = 0;
game.stopPlayerMove = false;
}
// No air control
if (!isplayeronground)
{
acceleration.acceleration1 = 0.99f;
acceleration.acceleration2 = 0.2f;
acceleration.acceleration3 = 70;
}
// Trampoline
{
int blockunderplayer = game.BlockUnderPlayer();
if (blockunderplayer != -1 && blockunderplayer == game.d_Data.BlockIdTrampoline() &&
(!isplayeronground) && !game.controls.shiftkeydown)
{
game.controls.wantsjump = true;
jumpstartacceleration = 20.666f * constGravity;
}
}
// Slippery walk on ice and when swimming
{
int blockunderplayer = game.BlockUnderPlayer();
if ((blockunderplayer != -1 && game.d_Data.IsSlipperyWalk()[blockunderplayer]) || game.SwimmingBody())
{
acceleration.acceleration1 = 0.99f;
acceleration.acceleration2 = 0.2f;
acceleration.acceleration3 = 70;
}
}
soundnow.value = false;
Vector3Ref diff1ref = new Vector3Ref();
VectorTool.ToVectorInFixedSystem
(move.movedx * movespeednow * dt,
0,
move.movedy * movespeednow * dt, stateplayerposition.rotx, stateplayerposition.roty, diff1ref);
Vector3Ref diff1 = new Vector3Ref();
diff1.X = diff1ref.X;
diff1.Y = diff1ref.Y;
diff1.Z = diff1ref.Z;
if (MiscCi.Vec3Length(push.X, push.Y, push.Z) > 0.01f)
{
push.Normalize();
push.X *= 5;
push.Y *= 5;
push.Z *= 5;
}
diff1.X += push.X * dt;
diff1.Y += push.Y * dt;
diff1.Z += push.Z * dt;
bool loaded = false;
int cx = game.platform.FloatToInt(game.player.position.x / Game.chunksize);
int cy = game.platform.FloatToInt(game.player.position.z / Game.chunksize);
int cz = game.platform.FloatToInt(game.player.position.y / Game.chunksize);
if (game.map.IsValidChunkPos(cx, cy, cz))
{
if (game.map.chunks[MapUtilCi.Index3d(cx, cy, cz,
game.map.MapSizeX / Game.chunksize,
game.map.MapSizeY / Game.chunksize)] != null)
{
loaded = true;
}
}
else
{
loaded = true;
}
if ((!(move.freemove)) && loaded)
{
if (!game.SwimmingBody())
{
movedz += -constGravity;//gravity
}
else
{
movedz += -constGravity * constWaterGravityMultiplier; //more gravity because it's slippery.
}
}
game.movedz = movedz;
if (constEnableAcceleration)
{
curspeed.X *= acceleration.acceleration1;
curspeed.Y *= acceleration.acceleration1;
curspeed.Z *= acceleration.acceleration1;
curspeed.X = MakeCloserToZero(curspeed.X, acceleration.acceleration2 * dt);
curspeed.Y = MakeCloserToZero(curspeed.Y, acceleration.acceleration2 * dt);
curspeed.Z = MakeCloserToZero(curspeed.Z, acceleration.acceleration2 * dt);
diff1.Y += move.moveup ? 2 * movespeednow * dt : 0;
diff1.Y -= move.movedown ? 2 * movespeednow * dt : 0;
curspeed.X += diff1.X * acceleration.acceleration3 * dt;
curspeed.Y += diff1.Y * acceleration.acceleration3 * dt;
curspeed.Z += diff1.Z * acceleration.acceleration3 * dt;
if (curspeed.Length() > movespeednow)
{
curspeed.Normalize();
curspeed.X *= movespeednow;
curspeed.Y *= movespeednow;
curspeed.Z *= movespeednow;
}
}
else
{
if (MiscCi.Vec3Length(diff1.X, diff1.Y, diff1.Z) > 0)
{
diff1.Normalize();
}
curspeed.X = diff1.X * movespeednow;
curspeed.Y = diff1.Y * movespeednow;
curspeed.Z = diff1.Z * movespeednow;
}
Vector3Ref newposition = Vector3Ref.Create(0, 0, 0);
if (!(move.freemove))
{
newposition.X = stateplayerposition.x + curspeed.X;
newposition.Y = stateplayerposition.y + curspeed.Y;
newposition.Z = stateplayerposition.z + curspeed.Z;
if (!game.SwimmingBody())
{
newposition.Y = stateplayerposition.y;
}
// Fast move when looking at the ground
float diffx = newposition.X - stateplayerposition.x;
float diffy = newposition.Y - stateplayerposition.y;
float diffz = newposition.Z - stateplayerposition.z;
float difflength = MiscCi.Vec3Length(diffx, diffy, diffz);
if (difflength > 0)
{
diffx /= difflength;
diffy /= difflength;
diffz /= difflength;
diffx *= curspeed.Length();
diffy *= curspeed.Length();
diffz *= curspeed.Length();
}
newposition.X = stateplayerposition.x + diffx * dt;
newposition.Y = stateplayerposition.y + diffy * dt;
newposition.Z = stateplayerposition.z + diffz * dt;
}
else
{
newposition.X = stateplayerposition.x + (curspeed.X) * dt;
newposition.Y = stateplayerposition.y + (curspeed.Y) * dt;
newposition.Z = stateplayerposition.z + (curspeed.Z) * dt;
}
newposition.Y += movedz * dt;
Vector3Ref previousposition = Vector3Ref.Create(stateplayerposition.x, stateplayerposition.y, stateplayerposition.z);
if (!move.noclip)
{
float[] v = WallSlide(
Vec3.FromValues(stateplayerposition.x, stateplayerposition.y, stateplayerposition.z),
Vec3.FromValues(newposition.X, newposition.Y, newposition.Z),
modelheight);
stateplayerposition.x = v[0];
stateplayerposition.y = v[1];
stateplayerposition.z = v[2];
}
else
{
stateplayerposition.x = newposition.X;
stateplayerposition.y = newposition.Y;
stateplayerposition.z = newposition.Z;
}
if (!(move.freemove))
{
if ((isplayeronground) || game.SwimmingBody())
{
jumpacceleration = 0;
movedz = 0;
}
if ((move.wantsjump || move.wantsjumphalf) && (((jumpacceleration == 0 && isplayeronground) || game.SwimmingBody()) && loaded) && (!game.SwimmingEyes()))
{
jumpacceleration = move.wantsjumphalf ? jumpstartaccelerationhalf : jumpstartacceleration;
soundnow.value = true;
}
if (jumpacceleration > 0)
{
isplayeronground = false;
jumpacceleration = jumpacceleration / 2;
}
//if (!this.reachedceiling)
{
movedz += jumpacceleration * constJump;
}
}
else
{
isplayeronground = true;
}
game.isplayeronground = isplayeronground;
}
public override void OnReadOnlyBackgroundThread(Game game_, float dt)
{
game = game_;
chunksize = Game.chunksize;
mapsizexchunks = game.map.MapSizeX / chunksize;
mapsizeychunks = game.map.MapSizeY / chunksize;
mapsizezchunks = game.map.MapSizeZ / chunksize;
int px = game.platform.FloatToInt(game.player.position.x) / chunksize;
int py = game.platform.FloatToInt(game.player.position.z) / chunksize;
int pz = game.platform.FloatToInt(game.player.position.y) / chunksize;
int chunksxy = this.mapAreaSize() / chunksize / 2;
int chunksz = this.mapAreaSizeZ() / chunksize / 2;
int startx = px - chunksxy;
int endx = px + chunksxy;
int starty = py - chunksxy;
int endy = py + chunksxy;
int startz = pz - chunksz;
int endz = pz + chunksz;
if (startx < 0)
{
startx = 0;
}
if (starty < 0)
{
starty = 0;
}
if (startz < 0)
{
startz = 0;
}
if (endx >= mapsizexchunks)
{
endx = mapsizexchunks - 1;
}
if (endy >= mapsizeychunks)
{
endy = mapsizeychunks - 1;
}
if (endz >= mapsizezchunks)
{
endz = mapsizezchunks - 1;
}
int mapsizexchunks_ = mapsizexchunks;
int mapsizeychunks_ = mapsizeychunks;
int mapsizezchunks_ = mapsizezchunks;
int count;
if (game.platform.IsFastSystem())
{
count = 1000;
}
else
{
count = 250;
}
for (int i = 0; i < count; i++)
{
unloadIterationXy++;
if (unloadIterationXy >= mapsizexchunks_ * mapsizeychunks_ * mapsizezchunks_)
{
unloadIterationXy = 0;
}
MapUtilCi.PosInt(unloadIterationXy, mapsizexchunks_, mapsizeychunks_, unloadxyztemp);
int x = unloadxyztemp.X;
int y = unloadxyztemp.Y;
int z = unloadxyztemp.Z;
int pos = MapUtilCi.Index3d(x, y, z, mapsizexchunks_, mapsizeychunks_);
bool unloaded = false;
Chunk c = game.map.chunks[pos];
if (c == null ||
c.rendered == null ||
c.rendered.ids == null)
{
continue;
}
if (x < startx || y < starty || z < startz ||
x > endx || y > endy || z > endz)
{
int unloadChunkPos = pos;
UnloadRendererChunksCommit commit = new UnloadRendererChunksCommit();
commit.game = game;
commit.unloadChunkPos = unloadChunkPos;
game.QueueActionCommit(commit);
}
unloaded = true;
if (unloaded)
{
break;
}
}
}
public override int GetBlock(int x, int y, int z)
{
ServerChunk chunk = GetChunk(x, y, z);
return(chunk.data[MapUtilCi.Index3d(x % chunksize, y % chunksize, z % chunksize, chunksize, chunksize)]);
}
