void RevertPhysics(Check C) { //attemps on shutdown to change blocks back into normal selves that are active, hopefully without needing to send into to clients. switch (blocks[C.b]) { case Block.Air_Flood: case Block.Air_FloodLayer: case Block.Air_FloodDown: case Block.Air_FloodUp: blocks[C.b] = 0; break; } try { PhysicsArgs args = C.data; // Copy paste here because it's worthwhile inlining if (args.Type1 == PhysicsArgs.Revert) { ushort x, y, z; IntToPos(C.b, out x, out y, out z); ExtBlock block = ExtBlock.FromRaw(args.Value1, args.ExtBlock); Blockchange(C.b, block, true, default(PhysicsArgs)); } else if (args.Type2 == PhysicsArgs.Revert) { ushort x, y, z; IntToPos(C.b, out x, out y, out z); ExtBlock block = ExtBlock.FromRaw(args.Value2, args.ExtBlock); Blockchange(C.b, block, true, default(PhysicsArgs)); } } catch (Exception e) { Logger.LogError(e); } }
void RevertPhysics(Check C) { //attemps on shutdown to change blocks back into normal selves that are active, hopefully without needing to send into to clients. switch (blocks[C.Index]) { case Block.Air_Flood: case Block.Air_FloodLayer: case Block.Air_FloodDown: case Block.Air_FloodUp: blocks[C.Index] = Block.Air; break; } try { PhysicsArgs args = C.data; // Copy paste here because it's worthwhile inlining if (args.Type1 == PhysicsArgs.Revert) { BlockID block = (BlockID)(args.Value1 | (args.ExtBlock << Block.ExtendedShift)); Blockchange(C.Index, block, true, default(PhysicsArgs)); } else if (args.Type2 == PhysicsArgs.Revert) { BlockID block = (BlockID)(args.Value2 | (args.ExtBlock << Block.ExtendedShift)); Blockchange(C.Index, block, true, default(PhysicsArgs)); } } catch (Exception e) { Logger.LogError(e); } }
internal bool AddUpdate(int b, ExtBlock block, bool overRide = false) { PhysicsArgs args = default(PhysicsArgs); args.ExtBlock = block.BlockID == Block.custom_block; return(AddUpdate(b, block.RawID, overRide, args)); }
internal bool AddUpdate(int index, BlockID block, bool overRide = false) { PhysicsArgs args = default(PhysicsArgs); args.Raw |= (uint)(PhysicsArgs.ExtBit * (block >> Block.ExtendedShift)); return(AddUpdate(index, block, args, overRide)); }
internal static ChangeResult Firework(Player p, BlockID old, ushort x, ushort y, ushort z) { if (p.level.physics == 0 || p.level.physics == 5) { return(ChangeResult.Unchanged); } Random rand = new Random(); // Offset the firework randomly Vec3U16 pos = new Vec3U16(0, 0, 0); pos.X = (ushort)(x + rand.Next(0, 2) - 1); pos.Z = (ushort)(z + rand.Next(0, 2) - 1); ushort headY = (ushort)(y + 2), tailY = (ushort)(y + 1); bool headFree = p.level.IsAirAt(pos.X, headY, pos.Z) && p.level.CheckClear(pos.X, headY, pos.Z); bool tailFree = p.level.IsAirAt(pos.X, tailY, pos.Z) && p.level.CheckClear(pos.X, tailY, pos.Z); if (headFree && tailFree) { p.level.Blockchange(pos.X, headY, pos.Z, Block.Fireworks); PhysicsArgs args = default(PhysicsArgs); args.Type1 = PhysicsArgs.Wait; args.Value1 = 1; args.Type2 = PhysicsArgs.Dissipate; args.Value2 = 100; p.level.Blockchange(pos.X, tailY, pos.Z, Block.StillLava, false, args); } return(ChangeResult.Unchanged); }
bool ParseArgs(Player p, string message, ref CatchPos cpos) { string[] parts = message.Split(' '); if (parts.Length % 2 == 1) { Player.SendMessage(p, "Number of parameters must be even"); Help(p); return(false); } PhysicsArgs args = default(PhysicsArgs); byte type = 0, value = 0; if (parts.Length >= 2) { if (!Parse(p, parts[0], parts[1], ref type, ref value)) { return(false); } args.Type1 = type; args.Value1 = value; } if (parts.Length >= 4) { if (!Parse(p, parts[2], parts[3], ref type, ref value)) { return(false); } args.Type2 = type; args.Value2 = value; } if (parts.Length >= 6) { Player.SendMessage(p, "You can only use up to two types of physics."); return(false); } cpos.extraInfo = args; return(true); }
bool ParseArgs(Player p, string message, ref PhysicsArgs extraInfo) { string[] parts = message.Split(' '); if (parts.Length % 2 == 1) { Player.Message(p, "Number of parameters must be even"); Help(p); return(false); } byte type = 0, value = 0; if (parts.Length >= 2) { if (!Parse(p, parts[0], parts[1], ref type, ref value)) { return(false); } extraInfo.Type1 = type; extraInfo.Value1 = value; } if (parts.Length >= 4) { if (!Parse(p, parts[2], parts[3], ref type, ref value)) { return(false); } extraInfo.Type2 = type; extraInfo.Value2 = value; } if (parts.Length >= 6) { Player.Message(p, "You can only use up to two types of physics."); return(false); } return(true); }
void RevertPhysics(Check C) { //attemps on shutdown to change blocks back into normal selves that are active, hopefully without needing to send into to clients. switch (blocks[C.b]) { case Block.air_flood: case Block.air_flood_layer: case Block.air_flood_down: case Block.air_flood_up: blocks[C.b] = 0; break; } try { PhysicsArgs args = C.data; if (args.Type1 == PhysicsArgs.Revert) { RevertBlock(C.b, args.Value1, args.ExtBlock); } else if (args.Type2 == PhysicsArgs.Revert) { RevertBlock(C.b, args.Value2, args.ExtBlock); } } catch (Exception e) { Server.ErrorLog(e); } }
bool ParseArgs(Player p, string message, ref PhysicsArgs args) { string[] parts = message.SplitSpaces(); if (parts.Length % 2 == 1) { p.Message("Number of parameters must be even"); Help(p); return(false); } byte type = 0, value = 0; byte extBits = 0; if (parts.Length >= 2) { if (!Parse(p, parts[0], parts[1], ref type, ref value, ref extBits)) { return(false); } args.Type1 = type; args.Value1 = value; } if (parts.Length >= 4) { if (!Parse(p, parts[2], parts[3], ref type, ref value, ref extBits)) { return(false); } args.Type2 = type; args.Value2 = value; } if (parts.Length >= 6) { p.Message("You can only use up to two types of physics."); return(false); } args.ExtBlock = extBits; return(true); }
public void Blockchange(int b, ExtBlock block, bool overRide = false, PhysicsArgs data = default(PhysicsArgs), bool addUndo = true) //Block change made by physics { if (DoPhysicsBlockchange(b, block, overRide, data, addUndo)) { Player.GlobalBlockchange(this, b, block); } }
public static void Call(ushort x, ushort y, ushort z, PhysicsArgs extraInfo, Level l) { if (handlers.Count == 0) { return; } CallCommon(pl => pl(x, y, z, extraInfo, l)); }
public void Blockchange(int b, byte type, bool overRide = false, PhysicsArgs data = default(PhysicsArgs), byte extType = 0, bool addUndo = true) //Block change made by physics { if (DoPhysicsBlockchange(b, type, overRide, data, extType, addUndo)) { Player.GlobalBlockchange(this, b, type, extType); } }
internal bool AddUpdate(int index, BlockID block, PhysicsArgs data, bool overRide = false) { try { int x = index % Width; int y = (index / Width) / Length; int z = (index / Width) % Length; if (x >= Width || y >= Height || z >= Length) { return(false); } if (overRide) { // Is the Ext flag just an indicator for the block update? if (data.ExtBlock != 0 && (data.Raw & PhysicsArgs.TypeMask) == 0) { data.Raw &= ~PhysicsArgs.ExtBits; } AddCheck(index, true, data); //Dont need to check physics here....AddCheck will do that Blockchange((ushort)x, (ushort)y, (ushort)z, block, true, data); return(true); } if (listUpdateExists.TrySetOn(x, y, z)) { } else if (block == Block.Sand || block == Block.Gravel) { RemoveUpdatesAtPos(index); } else { return(false); } if ((byte)block != block) { data.Data = Block.Obsidian; } else { data.Data = (byte)block; } Update update; update.Index = index; update.data = data; ListUpdate.Add(update); if (!physThreadStarted && physics > 0) { StartPhysics(); } return(true); } catch { //s.Log("Warning-PhysicsUpdate"); //ListUpdate.Add(new Update(b, (byte)type)); //Lousy back up plan return(false); } }
void AddTntCheck(int b, Player p) { PhysicsArgs args = default(PhysicsArgs); args.Type1 = PhysicsArgs.Custom; args.Value1 = (byte)p.SessionID; args.Value2 = (byte)(p.SessionID >> 8); args.Data = (byte)(p.SessionID >> 16); Map.AddCheck(b, false, args); }
void AddTntCheck(int b, Player p) { PhysicsArgs args = default(PhysicsArgs); args.Type1 = PhysicsArgs.TntWars; args.Value1 = (byte)p.tntWarsUuid; args.Value2 = (byte)(p.tntWarsUuid >> 8); args.Data = (byte)(p.tntWarsUuid >> 16); AddCheck(b, false, args); }
public static void Call(ushort x, ushort y, ushort z, PhysicsArgs extraInfo, Level l) { events.ForEach( pl => { try { pl.method(x, y, z, extraInfo, l); } catch (Exception e) { Server.s.Log("Plugin " + pl.plugin.name + " errored when calling PhysicsUpdate Event."); Server.ErrorLog(e); } }); }
internal bool AddUpdate(int b, byte type, bool overRide, PhysicsArgs data) { try { int x = b % Width; int y = (b / Width) / Length; int z = (b / Width) % Length; if (x >= Width || y >= Height || z >= Length) { return(false); } if (overRide) { ExtBlock block; block.BlockID = type; block.ExtID = 0; // Is the Ext flag just an indicator for the block update? if (data.ExtBlock && (data.Raw & PhysicsArgs.TypeMask) == 0) { block.ExtID = block.BlockID; block.BlockID = Block.custom_block; data.ExtBlock = false; } AddCheck(b, true, data); //Dont need to check physics here....AddCheck will do that Blockchange((ushort)x, (ushort)y, (ushort)z, block, true, data); return(true); } if (!listUpdateExists.Get(x, y, z)) { listUpdateExists.Set(x, y, z, true); } else if (type == Block.Sand || type == Block.Gravel) { RemoveUpdatesAtPos(b); } else { return(false); } ListUpdate.Add(new Update(b, (byte)type, data)); if (!physThreadStarted && physics > 0) { StartPhysics(); } return(true); } catch { //s.Log("Warning-PhysicsUpdate"); //ListUpdate.Add(new Update(b, (byte)type)); //Lousy back up plan return(false); } }
internal static void Door(Player p, ExtBlock block, ushort x, ushort y, ushort z) { if (p.level.physics != 0) { byte physForm; PhysicsArgs args = ActivateablePhysics.GetDoorArgs(block, out physForm); p.level.Blockchange(x, y, z, (ExtBlock)physForm, false, args); } else { p.RevertBlock(x, y, z); } }
internal static bool Door(Player p, BlockID block, ushort x, ushort y, ushort z) { if (p.level.physics == 0) { return(true); } BlockID physForm; PhysicsArgs args = ActivateablePhysics.GetDoorArgs(block, out physForm); p.level.Blockchange(x, y, z, physForm, false, args); return(true); }
public override void Use(Player p, string message, CommandData data) { PhysicsArgs extraInfo = default(PhysicsArgs); message = message.ToLower(); if (message.Length > 0 && !ParseArgs(p, message, ref extraInfo)) { return; } p.Message("Place or break two blocks to determine the edges."); p.MakeSelection(2, "Selecting region for &SRestart physics", extraInfo, DoRestart); }
public override void Use(Player p, string message) { PhysicsArgs extraInfo = default(PhysicsArgs); message = message.ToLower(); if (message != "" && !ParseArgs(p, message, ref extraInfo)) { return; } Player.Message(p, "Place two blocks to determine the edges."); p.MakeSelection(2, extraInfo, DoRestart); }
public void Blockchange(int b, BlockID block, bool overRide = false, PhysicsArgs data = default(PhysicsArgs), bool addUndo = true) //Block change made by physics { if (!DoPhysicsBlockchange(b, block, overRide, data, addUndo)) { return; } ushort x, y, z; IntToPos(b, out x, out y, out z); BroadcastChange(x, y, z, block); }
internal static ChangeResult Door(Player p, BlockID old, ushort x, ushort y, ushort z) { if (p.level.physics == 0) { return(p.ChangeBlock(x, y, z, Block.Air)); } BlockID physForm; PhysicsArgs args = ActivateablePhysics.GetDoorArgs(old, out physForm); p.level.Blockchange(x, y, z, physForm, false, args); return(ChangeResult.Modified); }
void RevertPhysics(Check C) { ushort x, y, z; IntToPos(C.b, out x, out y, out z); //attemps on shutdown to change blocks back into normal selves that are active, hopefully without needing to send into to clients. switch (blocks[C.b]) { case Block.air_flood: case Block.air_flood_layer: case Block.air_flood_down: case Block.air_flood_up: blocks[C.b] = 0; break; case Block.door_tree_air: //blocks[C.b] = 111; Blockchange(x, y, z, Block.door_tree); break; case Block.door_obsidian_air: //blocks[C.b] = 113; Blockchange(x, y, z, Block.door_obsidian); break; case Block.door_glass_air: //blocks[C.b] = 114; Blockchange(x, y, z, Block.door_glass); break; case Block.door_stone_air: //blocks[C.b] = 115; Blockchange(x, y, z, Block.door_stone); break; } try { if (!(C.data is PhysicsArgs)) { return; } PhysicsArgs args = (PhysicsArgs)C.data; if (args.Type1 == PhysicsArgs.Revert) { Blockchange(x, y, z, args.Value1, true); } if (args.Type2 == PhysicsArgs.Revert) { Blockchange(x, y, z, args.Value2, true); } } catch (Exception e) { Server.ErrorLog(e); } }
bool DoRestart(Player p, Vec3S32[] m, object state, byte type, byte extType) { PhysicsArgs extraInfo = (PhysicsArgs)state; List <int> buffer = new List <int>(); for (int y = Math.Min(m[0].Y, m[1].Y); y <= Math.Max(m[0].Y, m[1].Y); y++) { for (int z = Math.Min(m[0].Z, m[1].Z); z <= Math.Max(m[0].Z, m[1].Z); z++) { for (int x = Math.Min(m[0].X, m[1].X); x <= Math.Max(m[0].X, m[1].X); x++) { int index = p.level.PosToInt((ushort)x, (ushort)y, (ushort)z); if (index >= 0 && p.level.blocks[index] != Block.air) { buffer.Add(index); } } } } if (extraInfo.Raw == 0) { if (buffer.Count > Server.rpNormLimit) { Player.Message(p, "Cannot restart more than " + Server.rpNormLimit + " blocks."); Player.Message(p, "Tried to restart " + buffer.Count + " blocks."); return(false); } } else if (buffer.Count > Server.rpLimit) { Player.Message(p, "Tried to add physics to " + buffer.Count + " blocks."); Player.Message(p, "Cannot add physics to more than " + Server.rpLimit + " blocks."); return(false); } foreach (int index in buffer) { p.level.AddCheck(index, true, extraInfo); } Player.Message(p, "Activated " + buffer.Count + " blocks."); return(true); }
internal bool AddUpdate(int b, int type, bool overRide, PhysicsArgs data) { try { int x = b % Width; int y = (b / Width) / Length; int z = (b / Width) % Length; if (x >= Width || y >= Height || z >= Length) { return(false); } if (overRide) { AddCheck(b, true, data); //Dont need to check physics here....AddCheck will do that Blockchange((ushort)x, (ushort)y, (ushort)z, (byte)type, true, data); return(true); } if (!listUpdateExists.Get(x, y, z)) { listUpdateExists.Set(x, y, z, true); } else if (type == Block.sand || type == Block.gravel) { RemoveUpdatesAtPos(b); } else { return(false); } ListUpdate.Add(new Update(b, (byte)type, data)); if (!physicssate && physics > 0) { StartPhysics(); } return(true); } catch { //s.Log("Warning-PhysicsUpdate"); //ListUpdate.Add(new Update(b, (byte)type)); //Lousy back up plan return(false); } }
bool DoRestart(Player p, Vec3S32[] m, object state, BlockID block) { PhysicsArgs extraInfo = (PhysicsArgs)state; List <int> buffer = new List <int>(); int index; for (int y = Math.Min(m[0].Y, m[1].Y); y <= Math.Max(m[0].Y, m[1].Y); y++) { for (int z = Math.Min(m[0].Z, m[1].Z); z <= Math.Max(m[0].Z, m[1].Z); z++) { for (int x = Math.Min(m[0].X, m[1].X); x <= Math.Max(m[0].X, m[1].X); x++) { if (!p.level.IsAirAt((ushort)x, (ushort)y, (ushort)z, out index)) { buffer.Add(index); } } } } if (extraInfo.Raw == 0) { if (buffer.Count > Server.Config.PhysicsRestartNormLimit) { p.Message("Cannot restart more than " + Server.Config.PhysicsRestartNormLimit + " blocks."); p.Message("Tried to restart " + buffer.Count + " blocks."); return(false); } } else if (buffer.Count > Server.Config.PhysicsRestartLimit) { p.Message("Tried to add physics to " + buffer.Count + " blocks."); p.Message("Cannot add physics to more than " + Server.Config.PhysicsRestartLimit + " blocks."); return(false); } foreach (int index1 in buffer) { p.level.AddCheck(index1, true, extraInfo); } p.Message("Activated " + buffer.Count + " blocks."); return(true); }
static Player GetPlayer(ref PhysicsArgs args) { if (args.Type1 != PhysicsArgs.Custom) { return(null); } int id = args.Value1 | args.Value2 << 8 | (args.Data & 0xF) << 16; Player[] players = PlayerInfo.Online.Items; for (int i = 0; i < players.Length; i++) { if (players[i].SessionID == id) { return(players[i]); } } return(null); }
internal static bool Door(Player p, byte block, ushort x, ushort y, ushort z) { if (p.level.physics == 0) { return(true); } bool isExt = false; if (block == Block.custom_block) { isExt = true; block = p.level.GetExtTile(x, y, z); } byte physForm; PhysicsArgs args = ActivateablePhysics.GetDoorArgs(block, isExt, out physForm); p.level.Blockchange(x, y, z, physForm, false, args); return(true); }
public void AddCheck(int index, bool overRide, PhysicsArgs data) { try { int x = index % Width; int y = (index / Width) / Length; int z = (index / Width) % Length; if (x >= Width || y >= Height || z >= Length) { return; } if (listCheckExists.TrySetOn(x, y, z)) { Check check; check.Index = index; check.data = data; ListCheck.Add(check); // Adds block to list to be updated } else if (overRide) { Check[] items = ListCheck.Items; int count = ListCheck.Count; for (int i = 0; i < count; i++) { if (items[i].Index != index) { continue; } items[i].data = data; return; } //Dont need to check physics here because if the list is active, then physics is active :) } if (!physThreadStarted && physics > 0) { StartPhysics(); } } catch { //s.Log("Warning-PhysicsCheck"); //ListCheck.Add(new Check(b)); //Lousy back up plan } }