public override void Use(Player p, string message) {
string[] parts = message.Split(' ');
for (int i = 0; i < parts.Length; i++)
parts[i] = parts[i].ToLower();
if (message == "") {
if (bd != null)
SendStepHelp(p, step);
else
Help(p);
return;
}
switch (parts[0]) {
case "add":
case "create":
AddHandler(p, parts); break;
case "delete":
case "remove":
RemoveHandler(p, parts); break;
case "list":
case "ids":
ListHandler(p, parts); break;
case "abort":
Player.SendMessage(p, "Aborted the custom block creation process.");
bd = null; break;
default:
if (bd != null)
DefineBlockStep(p, message);
else
Help(p);
break;
}
}
public static void CreateAttributes(BlockDefinition[] input)
{
// Note that input is an unsorted array not suitable for indexing with BlockType
attributes = new BlockAttribute[System.Enum.GetNames(typeof(BlockType)).Length];
foreach (BlockDefinition d in input)
{
attributes[(int)d.type] = new BlockAttribute(d.isDiggable, d.isBreakable, d.isTransparent);
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static Image GenerateProxy(BlockManager manager, string rootPath, TemplateDefinition template, Dictionary <string, string> values)
{
var path = Path.Combine(rootPath, template.src);
Bitmap temp = GraphicUtils.LoadImage(path, PixelFormat.Format32bppArgb);
using (Graphics graphics = Graphics.FromImage(temp))
{
foreach (LinkDefinition overlay in template.GetOverLayBlocks(values))
{
BlockDefinition block = manager.GetBlock(overlay.Block);
if (block.type != "overlay")
{
continue;
}
block.src = Path.Combine(rootPath, block.src);
GraphicUtils.MergeOverlay(graphics, block);
}
foreach (LinkDefinition section in template.GetTextBlocks(values))
{
List <Property> clonedProps = new List <Property>();
BlockDefinition block = manager.GetBlock(section.Block);
if (block.type != "text")
{
continue;
}
clonedProps.AddRange(section.NestedProperties);
foreach (Property prop in section.NestedProperties)
{
if (!values.ContainsKey(prop.Name))
{
clonedProps.Remove(prop);
}
if (clonedProps.Contains(prop) && (values[prop.Name] == null || values[prop.Name].Length == 0))
{
clonedProps.Remove(prop);
}
}
StringBuilder toWrite = new StringBuilder();
if (clonedProps.Count > 1)
{
for (int i = 0; i < clonedProps.Count; i++)
{
string propertyName = clonedProps[i].Name;
string format = clonedProps[i].Format.Replace("{}", values[propertyName]);
if (i < (clonedProps.Count - 1))
{
toWrite.Append(string.Format("{0} {1}", format, section.Separator));
}
else
{
toWrite.Append(format);
}
}
}
else
{
if (clonedProps.Count > 0)
{
string propertyName = clonedProps[0].Name;
string format = clonedProps[0].Format.Replace("{}", values[propertyName]);
toWrite.Append(format);
}
}
GraphicUtils.WriteString(graphics, block, toWrite.ToString());
}
}
return(temp);
}
static void MakeDefineBlockEnd(BlockDefinition def, ref int i, byte[] buffer)
{
buffer[i++] = def.BlockDraw;
buffer[i++] = def.FogDensity;
buffer[i++] = def.FogR; buffer[i++] = def.FogG; buffer[i++] = def.FogB;
}
public void Initialize()
{
Vector3[] vertices = new Vector3[4 * 6];
Vector3[] normals = new Vector3[4 * 6];
int[] triangles = new int[6 * 6];
Vector2[] uvs = new Vector2[4 * 6];
Color[] colors = new Color[4 * 6];
Mesh mesh = new Mesh();
float s = 1.0f;
Vector3 normal;
int i = 0;
MeshFilter meshFilter = gameObject.GetComponent <MeshFilter>() as MeshFilter;
meshFilter.mesh = mesh;
CubeMesh = mesh;
// Top
normal = Vector3.up;
vertices[i] = new Vector3(-s, s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, s, s);
normals[i] = normal;
i++;
// Bottom
normal = Vector3.down;
vertices[i] = new Vector3(s, -s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, -s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, -s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, -s, s);
normals[i] = normal;
i++;
// North
normal = Vector3.back;
vertices[i] = new Vector3(-s, -s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, -s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, s, -s);
normals[i] = normal;
i++;
// South
normal = Vector3.forward;
vertices[i] = new Vector3(s, -s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, -s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, s, s);
normals[i] = normal;
i++;
// West
normal = Vector3.left;
vertices[i] = new Vector3(-s, -s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, -s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(-s, s, -s);
normals[i] = normal;
i++;
// East
normal = Vector3.right;
vertices[i] = new Vector3(s, -s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, s, -s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, -s, s);
normals[i] = normal;
i++;
vertices[i] = new Vector3(s, s, s);
normals[i] = normal;
i++;
// Finish
BlockDefinition blockDefinition = BlockDefinition.DefinitionOfType(BlockType.Dirt);
Block block = new Block();
block.Set(blockDefinition);
for (int j = 0; j < 6; j++)
{
Vector2 textureCoordinates = block.GetTextureCoordinates(CubeSide.Top, true, true, (byte)255);
Vector2 overallTextureSize = block.GetOverallTextureSize();
Vector2 individualTextureSize = block.GetIndividualTextureSize();
Vector2 lowerUVs, upperUVs;
lowerUVs.x = textureCoordinates.x / overallTextureSize.x;
lowerUVs.y = 1.0f - textureCoordinates.y / overallTextureSize.y;
upperUVs.x = (textureCoordinates.x + individualTextureSize.x) / overallTextureSize.x;
upperUVs.y = 1.0f - (textureCoordinates.y + individualTextureSize.y) / overallTextureSize.y;
Vector2 uv;
uv.x = lowerUVs.x;
uv.y = upperUVs.y;
uvs[j * 4 + 0] = uv;
uv.x = lowerUVs.x;
uv.y = lowerUVs.y;
uvs[j * 4 + 1] = uv;
uv.x = upperUVs.x;
uv.y = upperUVs.y;
uvs[j * 4 + 2] = uv;
uv.x = upperUVs.x;
uv.y = lowerUVs.y;
uvs[j * 4 + 3] = uv;
triangles[j * 6 + 0] = j * 4 + 0;
triangles[j * 6 + 1] = j * 4 + 1;
triangles[j * 6 + 2] = j * 4 + 2;
triangles[j * 6 + 3] = j * 4 + 1;
triangles[j * 6 + 4] = j * 4 + 3;
triangles[j * 6 + 5] = j * 4 + 2;
colors[j * 4 + 0] = Color.white;
colors[j * 4 + 1] = Color.white;
colors[j * 4 + 2] = Color.white;
colors[j * 4 + 3] = Color.white;
}
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.uv = uvs;
mesh.normals = normals;
mesh.colors = colors;
mesh.RecalculateBounds();
mesh.Optimize();
mesh.UploadMeshData(false);
gameObject.SetActive(false);
startingScale = transform.localScale * 0.5f;
}
public AtomicBlockBase(View hostView, Node parentNode, BlockBase parentBlock, BlockDefinition definition, FieldList content, bool isRoot)
: base(hostView, parentNode, parentBlock, definition, content, isRoot)
{
// setup events
Tap += new EventHandler <GestureEventArgs>(AtomicBlock_Tap);
Hold += new EventHandler <GestureEventArgs>(AtomicBlock_Hold);
}
static void EditHandler(Player p, string[] parts, bool global, string cmd)
{
if (parts.Length <= 3)
{
if (parts.Length == 1)
{
Player.Message(p, "Valid properties: " + helpSections.Keys.Join());
}
else if (parts.Length == 3)
{
Help(p, cmd, "edit " + parts[2]);
}
else
{
Help(p, cmd);
}
return;
}
ExtBlock block;
if (!CheckBlock(p, parts[1], out block))
{
return;
}
BlockDefinition[] defs = global ? BlockDefinition.GlobalDefs : p.level.CustomBlockDefs;
BlockDefinition def = defs[block.RawID], globalDef = BlockDefinition.GlobalDefs[block.RawID];
if (def == null && block.BlockID < Block.CpeCount)
{
def = DefaultSet.MakeCustomBlock(block.BlockID);
AddBlock(p, def, global, cmd, BlockDefinition.DefaultProps(block));
}
if (def != null && !global && def == globalDef)
{
def = globalDef.Copy();
AddBlock(p, def, global, cmd, BlockDefinition.DefaultProps(block));
}
if (!ExistsInScope(def, block, global))
{
MessageNoBlock(p, block, global, cmd); return;
}
string value = parts[3], blockName = def.Name;
float fTemp;
bool temp = false, changedFallback = false;
Level level = p == null ? null : p.level;
string arg = MapPropertyName(parts[2].ToLower());
switch (arg)
{
case "name":
def.Name = value; break;
case "collide":
if (!EditByte(p, value, "Collide type", ref def.CollideType, arg))
{
return;
}
break;
case "speed":
if (!Utils.TryParseDecimal(value, out fTemp) || fTemp < 0.25f || fTemp > 3.96f)
{
SendEditHelp(p, arg); return;
}
def.Speed = fTemp; break;
case "toptex":
if (!EditByte(p, value, "Top texture", ref def.TopTex, arg))
{
return;
}
break;
case "alltex":
if (!EditByte(p, value, "All textures", ref def.SideTex, arg))
{
return;
}
def.SetAllTex(def.SideTex);
break;
case "sidetex":
if (!EditByte(p, value, "Side texture", ref def.SideTex, arg))
{
return;
}
def.SetSideTex(def.SideTex);
break;
case "lefttex":
if (!EditByte(p, value, "Left texture", ref def.LeftTex, arg))
{
return;
}
break;
case "righttex":
if (!EditByte(p, value, "Right texture", ref def.RightTex, arg))
{
return;
}
break;
case "fronttex":
if (!EditByte(p, value, "Front texture", ref def.FrontTex, arg))
{
return;
}
break;
case "backtex":
if (!EditByte(p, value, "Back texture", ref def.BackTex, arg))
{
return;
}
break;
case "bottomtex":
if (!EditByte(p, value, "Bottom texture", ref def.BottomTex, arg))
{
return;
}
break;
case "blockslight":
if (!CommandParser.GetBool(p, value, ref temp))
{
SendEditHelp(p, arg); return;
}
def.BlocksLight = temp;
break;
case "sound":
if (!EditByte(p, value, "Walk sound", ref def.WalkSound, arg))
{
return;
}
break;
case "fullbright":
if (!CommandParser.GetBool(p, value, ref temp))
{
SendEditHelp(p, arg); return;
}
def.FullBright = temp;
break;
case "shape":
if (!CommandParser.GetBool(p, value, ref temp))
{
SendEditHelp(p, arg); return;
}
def.Shape = temp ? (byte)0 : def.MaxZ;
break;
case "blockdraw":
if (!EditByte(p, value, "Block draw", ref def.BlockDraw, arg))
{
return;
}
break;
case "min":
if (!ParseCoords(p, value, ref def.MinX, ref def.MinY, ref def.MinZ))
{
SendEditHelp(p, arg); return;
}
break;
case "max":
if (!ParseCoords(p, value, ref def.MaxX, ref def.MaxY, ref def.MaxZ))
{
SendEditHelp(p, arg); return;
}
break;
case "fogdensity":
if (!EditByte(p, value, "Fog density", ref def.FogDensity, arg))
{
return;
}
break;
case "fogcolor":
ColorDesc rgb = default(ColorDesc);
if (!CommandParser.GetHex(p, value, ref rgb))
{
return;
}
def.FogR = rgb.R; def.FogG = rgb.G; def.FogB = rgb.B;
break;
case "fallback":
byte fallback = GetFallback(p, value);
if (fallback == Block.Invalid)
{
return;
}
changedFallback = true;
value = Block.Name(fallback);
def.FallBack = fallback; break;
case "order":
int order = 0;
if (!CommandParser.GetInt(p, value, "Inventory order", ref order, 1, 255))
{
SendEditHelp(p, arg); return;
}
def.InventoryOrder = order == def.BlockID ? -1 : order;
BlockDefinition.UpdateOrder(def, global, level);
BlockDefinition.Save(global, level);
Player.Message(p, "Set inventory order for {0} to {1}", blockName,
order == def.BlockID ? "default" : order.ToString());
return;
default:
Player.Message(p, "Unrecognised property: " + arg); return;
}
Player.Message(p, "Set {0} for {1} to {2}", arg, blockName, value);
BlockDefinition.Add(def, defs, level);
if (changedFallback)
{
BlockDefinition.UpdateFallback(global, def.BlockID, level);
}
}
static string FormatBlock(BlockDefinition def)
{
return("Custom block %T" + def.BlockID + " %Shas name %T" + def.Name);
}
public static GraphicsPath GetTextPath(BlockDefinition section, string text, Graphics graphics)
{
GraphicsPath myPath = new GraphicsPath();
FontFamily family = new FontFamily("Arial");
FontStyle fontStyle = FontStyle.Regular;
if (section.text.font != null && File.Exists(Path.Combine(section.Manager.RootPath, section.text.font)))
{
PrivateFontCollection col = new PrivateFontCollection();
col.AddFontFile(Path.Combine(section.Manager.RootPath, section.text.font));
family = col.Families[0];
bool fontStyleFound = false;
foreach (var fontstyleEnum in Enum.GetValues(typeof(FontStyle)))
{
if (family.IsStyleAvailable(((FontStyle)fontstyleEnum)))
{
fontStyle = (FontStyle)fontstyleEnum;
fontStyleFound = true;
break;
}
foreach (var secondStyle in Enum.GetValues(typeof(FontStyle)))
{
var combinedStyle = ((FontStyle)fontstyleEnum) | ((FontStyle)secondStyle);
if (family.IsStyleAvailable(combinedStyle))
{
fontStyle = combinedStyle;
fontStyleFound = true;
break;
}
}
}
if (!fontStyleFound)
{
family = new FontFamily("Arial");
}
}
int size = section.text.size;
int minsize = 6;
Point location = section.location.ToPoint();
StringFormat format = StringFormat.GenericDefault;
if (section.wordwrap.height > 0)
{
format = new StringFormat();
format.Alignment = GetAlignment(section.wordwrap.align);
format.LineAlignment = GetAlignment(section.wordwrap.valign);
Size block = section.wordwrap.ToSize();
Rectangle rect = new Rectangle(location, block);
if (section.wordwrap.shrinkToFit)
{
GraphicsUnit original = graphics.PageUnit;
graphics.PageUnit = GraphicsUnit.Point; // Convert the PageUnit to Point just long enough to get an accurate measurement.
Font tempfont = new Font(family, size, fontStyle); // Create the font for the measurement.
SizeF unwrappedSize = graphics.MeasureString(text, tempfont);
if (unwrappedSize.Height > section.wordwrap.height)
{
if (unwrappedSize.Width > section.wordwrap.width)
{
int sizePerIncrement = (int)Math.Round((double)(unwrappedSize.Width / size), MidpointRounding.ToEven);
size = (int)Math.Round((double)(rect.Width / sizePerIncrement), MidpointRounding.ToEven);
size = (size < minsize) ? minsize : size;
tempfont = new Font(family, size, fontStyle);
}
}
else
{
float measuredHeight = graphics.MeasureString(text, tempfont, rect.Width, format).Height;
if (rect.Height < measuredHeight)
{
int sizePerIncrement = (int)Math.Round((double)(measuredHeight / unwrappedSize.Height), MidpointRounding.ToEven); //unwrappedSize.Height seems to be a better method of getting sizePerIncrement.
size = (int)Math.Round((double)(rect.Height / sizePerIncrement), MidpointRounding.ToEven);
size = (size < minsize) ? minsize : size;
tempfont = new Font(family, size, fontStyle);
}
}
while (size > minsize && rect.Height < graphics.MeasureString(text, tempfont, rect.Width, format).Height) // Compare the height of the rendered text to the bounding box. If it's larger
{
size -= 1; // Reduce the size, test again.
tempfont = new Font(family, size, fontStyle); // REcreate the font in the new size
}
// end addition
graphics.PageUnit = original; // Change the PageUnit back to display.
}
myPath.AddString(text,
family,
(int)fontStyle,
size,
rect,
format);
}
else
{
myPath.AddString(text,
family,
(int)fontStyle,
size,
location,
format);
}
return(myPath);
}
public BlockBase CreateAndInitialiseBlock(View hostView, Node parentNode, BlockBase parentBlock, BlockDefinition definition, FieldList contentData, bool isRoot)
{
if (definition != null)
{
BlockBase block = null;
if (definition is ContainerBlockDefinition)
{
ContainerBlockDefinition cdef = (ContainerBlockDefinition)definition;
switch (cdef.HintedType)
{
case UIHintedType.ApplicationBar:
block = new ApplicationBarBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.NativeMessageBox:
block = new NativeMessageBoxBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.TabBar:
block = new TabBarBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.ActionSheet:
block = new ActionSheetBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.Pivot:
block = new PivotBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.Panorama:
block = new PanoramaBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.None:
default:
{
if (cdef is BoxLayoutBlockDefinition)
{
block = new BoxLayoutBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
else if (cdef is GridBlockDefinition)
{
block = new GridBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
else if (cdef is ListBlockDefinition)
{
block = new ListBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
else if (cdef is FrameDefinition)
{
block = new FrameBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
break;
}
}
}
else if (definition is CommonAtomicBlockDefinition)
{
CommonAtomicBlockDefinition cabdef = (CommonAtomicBlockDefinition)definition;
switch (cabdef.HintedType)
{
case UIHintedType.ApplicationBarOptions:
block = new ApplicationBarOptionsBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.ApplicationBarButton:
block = new ApplicationBarButtonBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.ApplicationBarMenuItem:
block = new ApplicationBarMenuItemBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.NativeMessageBoxBody:
block = new NativeMessageBoxBodyBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.NativeMessageBoxButton:
block = new NativeMessageBoxButtonBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.TabBarButton:
block = new TabBarButtonBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.SystemTray:
block = new SystemTrayBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.Placeholder:
block = new PlaceholderBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
break;
case UIHintedType.None:
default:
{
if (cabdef is AtomicBlockDefinition)
{
block = new AtomicBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
else if (cabdef is SingleSlotBlockDefinition)
{
block = new SingleSlotBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
break;
}
}
}
else if (definition is ScrollingTextBlockDefinition)
{
block = new ScrollingTextBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
else if (definition is MapPluginBlockDefinition)
{
block = new MapPluginBlock(hostView, parentNode, parentBlock, definition, contentData, isRoot);
}
if (block != null)
{
if (block.IsHidden)
{
block.Visibility = Visibility.Collapsed;
}
return(block);
}
}
return(null);
}
public virtual void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
//objectBuilder.PersistentFlags |= MyPersistentEntityFlags2.CastShadows;
// Ensure that if we went from not serializing to serializing, we have a valid entity id.
if (builder.EntityId == 0)
{
EntityId = MyEntityIdentifier.AllocateId();
}
else if (builder.EntityId != 0)
{
EntityId = builder.EntityId;
}
NumberInGrid = cubeGrid.BlockCounter.GetNextNumber(builder.GetId());
Render.ColorMaskHsv = builder.ColorMaskHSV;
if (BlockDefinition.ContainsComputer())
{
m_IDModule = new MyIDModule();
if (MySession.Static.Settings.ResetOwnership && Sync.IsServer)
{
m_IDModule.Owner = 0;
m_IDModule.ShareMode = MyOwnershipShareModeEnum.None;
}
else
{
if ((int)builder.ShareMode == -1)
{
builder.ShareMode = MyOwnershipShareModeEnum.None;
}
var ownerType = MyEntityIdentifier.GetIdObjectType(builder.Owner);
if (builder.Owner != 0 && ownerType != MyEntityIdentifier.ID_OBJECT_TYPE.NPC && ownerType != MyEntityIdentifier.ID_OBJECT_TYPE.SPAWN_GROUP)
{
System.Diagnostics.Debug.Assert(ownerType == MyEntityIdentifier.ID_OBJECT_TYPE.IDENTITY, "Old save detected, reseting owner to Nobody, please resave.");
if (!Sync.Players.HasIdentity(builder.Owner))
{
builder.Owner = 0; //reset, it was old version
}
}
m_IDModule.Owner = builder.Owner;
m_IDModule.ShareMode = builder.ShareMode;
}
}
if (MyFakes.ENABLE_SUBBLOCKS)
{
if (builder.SubBlocks != null)
{
foreach (var subblockInfo in builder.SubBlocks)
{
m_subBlockIds.Add(subblockInfo.SubGridName, new MySubBlockLoadInfo()
{
GridId = subblockInfo.SubGridId, SubBlockPosition = subblockInfo.SubBlockPosition
});
}
m_subBlocksLoaded = m_subBlockIds.Count > 0;
if (BlockDefinition.SubBlockDefinitions != null && BlockDefinition.SubBlockDefinitions.Count > 0 && m_subBlockIds.Count == 0)
{
m_subBlocksInitialized = true;
m_subBlocksLoaded = true;
}
// Set update flag for InitSubBlocks
NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
}
base.Init(null);
base.Render.PersistentFlags |= MyPersistentEntityFlags2.CastShadows;
Init();
AddDebugRenderComponent(new MyDebugRenderComponentCubeBlock(this));
}
void GenerateBlocksThread(object chunkInstance)
{
Chunk chunk = chunkInstance as Chunk;
ChunkSubspacePosition position;
BlockSpacePosition checkPosition;
for (position.x = 0; position.x < SIZE; position.x++)
{
checkPosition.x = worldPosition.x * SIZE + position.x;
for (position.z = 0; position.z < SIZE; position.z++)
{
checkPosition.z = worldPosition.z * SIZE + position.z;
isShorelineCache[position.x, position.z] = true;
for (position.y = worldPosition.y * SIZE + SIZE; position.y < Configuration.HEIGHT; position.y++)
{
checkPosition.y = position.y;
Block checkBlock = ChunkRepository.GetBlockAtPosition(checkPosition);
if (checkBlock.IsActive() && checkBlock.IsNotTransparent())
{
isShorelineCache[position.x, position.z] = false;
break;
}
}
}
}
BlockType[,,] blockTypes = worldGenerator.GenerateBlocks(chunk);
for (position.x = 0; position.x < SIZE; position.x++)
{
for (position.y = 0; position.y < SIZE; position.y++)
{
for (position.z = 0; position.z < SIZE; position.z++)
{
BlockDefinition blockDefinition = BlockDefinition.DefinitionOfType(blockTypes[position.x, position.y, position.z]);
chunk.SetBlock(position, blockDefinition, false);
if (blockDefinition.IsActive() && blockDefinition.IsNotTransparent() &&
blockDefinition.GetBlockType() != BlockType.Sand)
{
isShorelineCache[position.x, position.z] = false;
}
if (blockDefinition.IsLightEmitter())
{
BlockLight light;
light.chunk = this;
light.chunkPosition = position;
light.blockDefinition = blockDefinition;
lock (chunk.padlock) {
chunk.lights.Add(light);
}
}
}
}
}
// Generate and apply the models from this and all nearby chunks
List <Model> generatedModels = worldGenerator.GenerateModels(chunk);
lock (generatingModelsLock) {
for (int i = 0; i < generatedModels.Count; i++)
{
AddModel(generatedModels[i]);
}
}
List <Chunk> lockedChunks = LockNearbyChunkModels();
ApplyModels();
UnlockChunkModels(lockedChunks);
// Cleanup pass
for (position.x = 0; position.x < SIZE; position.x++)
{
for (position.z = 0; position.z < SIZE; position.z++)
{
for (position.y = SIZE - 1; position.y >= 0; position.y--)
{
chunk.GetBlock(position);
// If the block is water, make sure it's surrounded on the bottom and sides
if (chunk.GetBlock(position).IsWater())
{
for (int i = 0; i < 5; i++)
{
ChunkSubspacePosition solidCheckPosition = position;
if (i == 0)
{
solidCheckPosition.y -= 1;
}
else if (i == 1)
{
solidCheckPosition.x -= 1;
}
else if (i == 2)
{
solidCheckPosition.x += 1;
}
else if (i == 3)
{
solidCheckPosition.z -= 1;
}
else if (i == 4)
{
solidCheckPosition.z += 1;
}
if (solidCheckPosition.x >= 0 && solidCheckPosition.x < SIZE &&
solidCheckPosition.y >= 0 && solidCheckPosition.y < SIZE &&
solidCheckPosition.z >= 0 && solidCheckPosition.z < SIZE)
{
if (chunk.GetBlock(solidCheckPosition).IsNotActive())
{
chunk.SetBlock(solidCheckPosition, BlockType.Stone, false);
}
}
else
{
BlockSpacePosition checkWorldPosition = solidCheckPosition.GetBlockSpacePosition(chunk);
if (ChunkRepository.GetBlockAtPosition(checkWorldPosition).IsNotActive())
{
ChunkRepository.SetBlockAtPosition(checkWorldPosition, BlockType.Stone, false);
}
}
}
}
}
}
}
LoadTransparencyCache();
chunk.SetLoadState(ChunkLoadState.BlockGenerationComplete);
}
private void SetBlock(ChunkSubspacePosition position, BlockType type, bool triggerLightingUpdate)
{
SetBlock(position, BlockDefinition.DefinitionOfType(type), triggerLightingUpdate);
}
static void ParseBlockDefinitions(NbtCompound cpe, Level lvl)
{
NbtCompound blocks = (NbtCompound)cpe["BlockDefinitions"];
bool hasBlockDefs = false;
foreach (NbtTag tag in blocks)
{
if (tag.TagType != NbtTagType.Compound)
{
continue;
}
NbtCompound props = (NbtCompound)tag;
BlockDefinition def = new BlockDefinition();
def.RawID = props["ID"].ByteValue;
// can't change "ID" to short since backwards compatibility
if (props.Contains("ID2"))
{
def.RawID = (ushort)props["ID2"].ShortValue;
}
def.Name = props["Name"].StringValue;
def.CollideType = props["CollideType"].ByteValue;
def.Speed = props["Speed"].FloatValue;
def.BlocksLight = props["TransmitsLight"].ByteValue == 0;
def.WalkSound = props["WalkSound"].ByteValue;
def.FullBright = props["FullBright"].ByteValue != 0;
def.Shape = props["Shape"].ByteValue;
def.BlockDraw = props["BlockDraw"].ByteValue;
byte[] fog = props["Fog"].ByteArrayValue;
def.FogDensity = fog[0];
// Fix for older ClassicalSharp versions which saved wrong value for density = 0
if (def.FogDensity == 0xFF)
{
def.FogDensity = 0;
}
def.FogR = fog[1]; def.FogG = fog[2]; def.FogB = fog[3];
byte[] tex = props["Textures"].ByteArrayValue;
def.TopTex = tex[0]; def.BottomTex = tex[1];
def.LeftTex = tex[2]; def.RightTex = tex[3];
def.FrontTex = tex[4]; def.BackTex = tex[5];
byte[] coords = props["Coords"].ByteArrayValue;
def.MinX = coords[0]; def.MinZ = coords[1]; def.MinY = coords[2];
def.MaxX = coords[3]; def.MaxZ = coords[4]; def.MaxY = coords[5];
BlockID block = def.GetBlock();
if (block >= Block.ExtendedCount)
{
Logger.Log(LogType.Warning, "Cannot import custom block {0} (ID {1})",
def.Name, def.RawID);
continue;
}
// Don't define level custom block if same as global custom block
BlockDefinition globalDef = BlockDefinition.GlobalDefs[block];
if (PropsEquals(def, globalDef))
{
continue;
}
lvl.UpdateCustomBlock(block, def);
hasBlockDefs = true;
}
if (hasBlockDefs)
{
BlockDefinition.Save(false, lvl);
}
}
void AddHandler(Player p, string[] parts) {
if (parts.Length >= 2 ) {
string id = parts[1];
if (!CheckBlockId(p, id, out targetId)) return;
BlockDefinition def = BlockDefinition.GlobalDefinitions[targetId];
if (def != null) {
Player.SendMessage(p, "There is already a custom block with the id " + id +
", you must either use a different id or use \"/gb remove " + id + "\"");
return;
}
} else {
targetId = GetFreeId();
if (targetId == Block.Zero) {
Player.SendMessage(p, "There are no custom block ids left, " +
"you must /gb remove a custom block first.");
return;
}
}
bd = new BlockDefinition();
Player.SendMessage(p, "Type '/gb abort' at anytime to abort the creation process.");
Player.SendMessage(p, "Type '/gb revert' to go back a step in the creation process.");
Player.SendMessage(p, "Use '/gb <arg>' to enter arguments for the creation process.");
Player.SendMessage(p, "%f----------------------------------------------------------");
step = 2;
SendStepHelp(p, step);
}
public override void Use(Player p, string message)
{
string[] args = message.SplitSpaces(2);
if (args.Length != 2)
{
Help(p); return;
}
BlockDefinition[] globalDefs = BlockDefinition.GlobalDefs;
BlockID src;
if (!CommandParser.GetBlock(p, args[0], out src))
{
return;
}
if (globalDefs[src] == null)
{
p.Message("&WNo global block with that ID for source."); return;
}
BlockID dst;
if (!CommandParser.GetBlock(p, args[1], out dst))
{
return;
}
if (globalDefs[dst] == null)
{
p.Message("&WNo global block with that ID for target."); return;
}
// lazy fix
if (globalDefs[src].InventoryOrder == -1)
{
p.Message("Give source block an explicit order first. (too lazy to fix)");
return;
}
// Sort block definitions by inventory position
List <BlockDefinition> defs = new List <BlockDefinition>();
foreach (BlockDefinition def in globalDefs)
{
if (def == null || def.InventoryOrder == 0)
{
continue;
}
defs.Add(def);
}
defs.Sort((a, b) => Order(a).CompareTo(Order(b)));
int srcOrder = Order(globalDefs[src]);
int dstOrder = Order(globalDefs[dst]);
// Shift all following block definitions after source down by one position
// A B C s X Y Z --> A B C X Y Z
for (int i = defs.Count - 1; i >= 0; i--)
{
if (Order(defs[i]) < srcOrder)
{
break;
}
defs[i].InventoryOrder = Order(defs[i]) - 1;
}
// Shift all following block definitions after target up by one position
// A B C t X Y Z --> A B C - t X Y Z
for (int i = defs.Count - 1; i >= 0; i--)
{
if (Order(defs[i]) < dstOrder)
{
break;
}
defs[i].InventoryOrder = Order(defs[i]) + 1;
}
// Insert source into spare slot just before target
globalDefs[src].InventoryOrder = dstOrder;
BlockDefinition.UpdateOrder(globalDefs[src], true, null);
BlockDefinition.Save(true, null);
p.Message("Inserted block. You might need to rejoin though.");
}
public void Init()
{
block = new TestBlock();
}
/// <summary>
///
/// </summary>
/// <param name="graphics"></param>
/// <param name="section"></param>
/// <param name="value"></param>
public static void WriteString(Graphics graphics, BlockDefinition section, string value)
{
if (value == null || value == string.Empty)
{
return;
}
graphics.SmoothingMode = SmoothingMode.AntiAlias;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
value = System.Web.HttpUtility.HtmlDecode(value);
GraphicsPath path = GetTextPath(section, value, graphics);
if (section.location.flip)
{
using (Matrix matrix = new Matrix())
{
matrix.Scale(-1, 1, MatrixOrder.Append);
path.Transform(matrix);
}
using (Matrix matrix = new Matrix())
{
float min = path.PathPoints.Min(p => p.X);
matrix.Translate(((-min) + section.location.x), 0);
path.Transform(matrix);
}
}
if (section.location.rotate > 0)
{
int rotateMod = section.location.rotate % 360;
if (!section.location.altrotate)
{
float centerX = 0;
float centerY = 0;
centerX = section.location.x;
centerY = section.location.y;
using (Matrix mat = new Matrix())
{
mat.RotateAt(rotateMod, new PointF(centerX, centerY), MatrixOrder.Append);
path.Transform(mat);
}
}
else
{
using (Matrix matrix = new Matrix())
{
matrix.Rotate(rotateMod, MatrixOrder.Append);
path.Transform(matrix);
}
using (Matrix matrix = new Matrix())
{
float minX = path.PathPoints.Min(p => p.X);
float minY = path.PathPoints.Min(p => p.Y);
matrix.Translate(((-minX) + section.location.x), ((-minY) + section.location.y));
path.Transform(matrix);
}
}
}
SolidBrush b = new SolidBrush(section.text.color);
if (section.border.size > 0)
{
Pen p = new Pen(section.border.color, section.border.size);
graphics.DrawPath(p, path);
graphics.FillPath(b, path);
p.Dispose();
}
else
{
graphics.FillPath(b, path);
}
b.Dispose();
path.Dispose();
}
public unsafe static void CompressMap(Player p, LevelChunkStream dst)
{
const int bufferSize = 64 * 1024;
byte[] buffer = new byte[bufferSize];
int bIndex = 0;
// Store on stack instead of performing function call for every block in map
byte *conv = stackalloc byte[Block.Count];
byte *convCPE = stackalloc byte[Block.Count];
for (int i = 0; i < 256; i++)
{
conv[i] = Block.Convert((byte)i);
}
// Convert custom blocks (that overwrote core blocks) to their fallbacks
if (!p.hasBlockDefs)
{
for (int i = 0; i < Block.CpeCount; i++)
{
BlockDefinition def = p.level.CustomBlockDefs[i];
if (def != null)
{
conv[i] = def.FallBack;
}
}
}
// Convert CPE blocks to their fallbacks
if (!p.hasCustomBlocks)
{
for (int i = 0; i < Block.Count; i++)
{
convCPE[i] = Block.ConvertCPE((byte)i);
conv[i] = Block.ConvertCPE(conv[i]);
}
}
Level lvl = p.level;
bool hasBlockDefs = p.hasBlockDefs;
using (GZipStream gs = new GZipStream(dst, CompressionMode.Compress, true)) {
byte[] blocks = lvl.blocks;
NetUtils.WriteI32(blocks.Length, buffer, 0);
gs.Write(buffer, 0, sizeof(int));
dst.length = blocks.Length;
// compress the map data in 64 kb chunks
if (p.hasCustomBlocks)
{
for (int i = 0; i < blocks.Length; ++i)
{
byte block = blocks[i];
if (block == Block.custom_block)
{
buffer[bIndex] = hasBlockDefs ? lvl.GetExtTile(i) : lvl.GetFallbackExtTile(i);
}
else
{
buffer[bIndex] = conv[block];
}
bIndex++;
if (bIndex == bufferSize)
{
dst.position = i;
gs.Write(buffer, 0, bufferSize); bIndex = 0;
}
}
}
else
{
for (int i = 0; i < blocks.Length; ++i)
{
byte block = blocks[i];
if (block == Block.custom_block)
{
block = hasBlockDefs ? lvl.GetExtTile(i) : lvl.GetFallbackExtTile(i);
buffer[bIndex] = convCPE[block];
}
else
{
buffer[bIndex] = conv[block];
}
bIndex++;
if (bIndex == bufferSize)
{
dst.position = i;
gs.Write(buffer, 0, bufferSize); bIndex = 0;
}
}
}
if (bIndex > 0)
{
gs.Write(buffer, 0, bIndex);
}
}
}
private void UnpackContent()
{
// parse settings
if (Data != null)
{
loadOnDemand = Data.RenderingHints[RenderingHintKey.OnDemand].Equals(WaveConstant.True, StringComparison.InvariantCultureIgnoreCase);
}
// creating children
List <FieldList> children = Content.GetItems <FieldList>(NaviAgentFieldID.BlockData);
AtomicBlock title = null;
List <AtomicBlock> itemTitles = new List <AtomicBlock>();
List <FrameBlock> items = new List <FrameBlock>();
for (int i = 0; i < children.Count; i++)
{
int childDefinitionID = children[i][MessageOutFieldID.DefinitionID].AsInteger() ?? 0;
BlockDefinition definition = Core.Definitions.Find(ParentNode.ApplicationID, childDefinitionID, true) as BlockDefinition;
if (definition != null)
{
if (definition is FrameDefinition)
{
items.Add(new FrameBlock(Host, ParentNode, this, definition as FrameDefinition, children[i], false, !loadOnDemand));
}
else
{
AtomicBlock newBlock = Core.UIFactory.CreateAndInitialiseBlock(Host, ParentNode, this, definition, children[i], false) as AtomicBlock;
if (newBlock != null)
{
if (definition.HintedType == UIHintedType.PivotTitle)
{
title = newBlock;
}
else
{
itemTitles.Add(newBlock);
}
}
}
}
}
if ((title != null) && !String.IsNullOrWhiteSpace(title.Caption) && (itemTitles.Count > 0) && (items.Count > 0) && (itemTitles.Count == items.Count))
{
pivot = new Pivot();
pivot.Title = title.Caption;
pivot.LoadingPivotItem += new EventHandler <PivotItemEventArgs>(pivot_LoadingPivotItem);
for (int i = 0; i < items.Count; i++)
{
PivotItem item = new PivotItem();
item.Header = !String.IsNullOrWhiteSpace(itemTitles[i].Caption) ? itemTitles[i].Caption : WaveConstant.UnknownText;
item.Content = items[i];
pivot.Items.Add(item);
}
if ((ContainerDefinition != null) && ContainerDefinition.Background.HasValue)
{
PaintStyleResult bgRes = ResolvePaintStyle(ContainerDefinition.Background.Value);
if (bgRes.Brush != null)
{
pivot.Background = bgRes.Brush;
}
}
Children.Add(pivot);
for (int i = 0; i < items.Count; i++)
{
WaveChildren.Add(items[i]);
}
}
}
static void DefineBlockStep(Player p, string value, bool global, string cmd)
{
string opt = value.ToLower();
int step = GetStep(p, global);
BlockDefinition bd = GetBD(p, global);
bool temp = false;
if (opt == "revert" && step > 2)
{
if (step == 17 && bd.FogDensity == 0)
{
step -= 2;
}
else if (step == 9 && bd.Shape == 0)
{
step -= 5;
}
else
{
step--;
}
SetStep(p, global, step);
SendStepHelp(p, global);
return;
}
if (step == 2)
{
bd.Name = value;
step++;
}
else if (step == 3)
{
if (CommandParser.GetBool(p, value, ref temp))
{
bd.Shape = temp ? (byte)0 : (byte)16;
step++;
}
}
else if (step == 4)
{
if (CommandParser.GetByte(p, value, "Texture ID", ref bd.TopTex))
{
step += (bd.Shape == 0 ? 5 : 1); // skip other texture steps for sprites
if (bd.Shape == 0)
{
bd.SetAllTex(bd.TopTex);
}
}
}
else if (step == 5)
{
if (CommandParser.GetByte(p, value, "Texture ID", ref bd.SideTex))
{
bd.SetSideTex(bd.SideTex);
step++;
}
}
else if (step == 6)
{
if (CommandParser.GetByte(p, value, "Texture ID", ref bd.BottomTex))
{
step++;
}
}
else if (step == 7)
{
if (ParseCoords(p, value, ref bd.MinX, ref bd.MinY, ref bd.MinZ))
{
step++;
}
}
else if (step == 8)
{
if (ParseCoords(p, value, ref bd.MaxX, ref bd.MaxY, ref bd.MaxZ))
{
step++;
}
bd.Shape = bd.MaxY;
}
else if (step == 9)
{
if (CommandParser.GetByte(p, value, "Collide type", ref bd.CollideType, 0, 6))
{
step++;
}
}
else if (step == 10)
{
if (Utils.TryParseDecimal(value, out bd.Speed) && bd.Speed >= 0.25f && bd.Speed <= 3.96f)
{
step++;
}
}
else if (step == 11)
{
if (CommandParser.GetBool(p, value, ref temp))
{
bd.BlocksLight = temp;
step++;
}
}
else if (step == 12)
{
if (CommandParser.GetByte(p, value, "Walk sound", ref bd.WalkSound, 0, 11))
{
step++;
}
}
else if (step == 13)
{
if (CommandParser.GetBool(p, value, ref bd.FullBright))
{
step++;
}
}
else if (step == 14)
{
if (CommandParser.GetByte(p, value, "Block draw", ref bd.BlockDraw, 0, 4))
{
step++;
}
}
else if (step == 15)
{
if (CommandParser.GetByte(p, value, "Fog density", ref bd.FogDensity))
{
step += (bd.FogDensity == 0 ? 2 : 1);
}
}
else if (step == 16)
{
ColorDesc rgb = default(ColorDesc);
if (CommandParser.GetHex(p, value, ref rgb))
{
bd.FogR = rgb.R; bd.FogG = rgb.G; bd.FogB = rgb.B;
step++;
}
}
else if (step == 17)
{
byte fallback = GetFallback(p, value);
if (fallback == Block.Invalid)
{
SendStepHelp(p, global); return;
}
bd.FallBack = fallback;
ExtBlock block = ExtBlock.FromRaw(bd.BlockID);
BlockProps props = BlockDefinition.DefaultProps(block);
if (!AddBlock(p, bd, global, cmd, props))
{
return;
}
SetBD(p, global, null);
SetStep(p, global, 0);
return;
}
SetStep(p, global, step);
SendStepHelp(p, global);
}
public static BlockDefinition DeserializeBlock(string rootPath, XmlNode node)
{
BlockDefinition ret = new BlockDefinition();
ret.id = node.Attributes["id"].Value;
ret.type = node.Attributes["type"].Value;
if (node.Attributes["src"] != null)
{
//todo: make sure the src exists and figure out what to do if it doesn't
ret.src = Path.Combine(rootPath, node.Attributes["src"].Value);
}
foreach (XmlNode prop in node.ChildNodes)
{
if (SkipNode(prop))
{
continue;
}
if (prop.Name.Equals("location"))
{
ret.location.x = int.Parse(prop.Attributes["x"].Value);
ret.location.y = int.Parse(prop.Attributes["y"].Value);
if (prop.Attributes["rotate"] != null)
{
ret.location.rotate = int.Parse(prop.Attributes["rotate"].Value);
}
if (prop.Attributes["altrotate"] != null)
{
ret.location.altrotate = bool.Parse(prop.Attributes["altrotate"].Value);
}
if (prop.Attributes["flip"] != null)
{
ret.location.flip = bool.Parse(prop.Attributes["flip"].Value);
}
}
if (prop.Name.Equals("text"))
{
ret.text.color = ColorTranslator.FromHtml(prop.Attributes["color"].Value);
ret.text.size = int.Parse(prop.Attributes["size"].Value);
if (prop.Attributes["font"] != null)
{
string combined = Path.Combine(rootPath, prop.Attributes["font"].Value);
if (File.Exists(combined))
{
ret.text.font = combined;
}
}
}
if (prop.Name.Equals("border"))
{
ret.border.color = ColorTranslator.FromHtml(prop.Attributes["color"].Value);
ret.border.size = int.Parse(prop.Attributes["size"].Value);
}
if (prop.Name.Equals("wordwrap"))
{
ret.wordwrap.height = int.Parse(prop.Attributes["height"].Value);
ret.wordwrap.width = int.Parse(prop.Attributes["width"].Value);
if (prop.Attributes["align"] != null)
{
ret.wordwrap.align = prop.Attributes["align"].Value;
}
if (prop.Attributes["valign"] != null)
{
ret.wordwrap.valign = prop.Attributes["valign"].Value;
}
if (prop.Attributes["shrinktofit"] != null)
{
ret.wordwrap.shrinkToFit = bool.Parse(prop.Attributes["shrinktofit"].Value);
}
}
}
return(ret);
}
static bool ExistsInScope(BlockDefinition def, ExtBlock block, bool global)
{
return(def != null && (global ? true : def != BlockDefinition.GlobalDefs[block.RawID]));
}
public static void AddCustomFields(MyCubeBlockDefinition myBlockDefinition, BlockDefinition blockDefinition)
{
if (myBlockDefinition is MyAirtightDoorGenericDefinition myAirtightDoorGenericDefinition &&
blockDefinition is AirtightDoorGenericDefinition airtightDoorGenericDefinition)
{
airtightDoorGenericDefinition.PowerConsumptionIdle = myAirtightDoorGenericDefinition.PowerConsumptionIdle;
airtightDoorGenericDefinition.PowerConsumptionMoving = myAirtightDoorGenericDefinition.PowerConsumptionMoving;
airtightDoorGenericDefinition.OpeningSpeed = myAirtightDoorGenericDefinition.OpeningSpeed;
}
if (myBlockDefinition is MyLCDPanelsBlockDefinition myLCDPanelsBlockDefinition &&
blockDefinition is LCDPanelsBlockDefinition lCDPanelsBlockDefinition)
{
lCDPanelsBlockDefinition.RequiredPowerInput = myLCDPanelsBlockDefinition.RequiredPowerInput;
}
if (myBlockDefinition is MyPowerProducerDefinition myPowerProducerDefinition &&
blockDefinition is PowerProducerDefinition powerProducerDefinition)
{
powerProducerDefinition.MaxPowerOutput = myPowerProducerDefinition.MaxPowerOutput;
}
if (myBlockDefinition is MyAdvancedDoorDefinition myAdvancedDoorDefinition &&
blockDefinition is AdvancedDoorDefinition advancedDoorDefinition)
{
advancedDoorDefinition.PowerConsumptionIdle = myAdvancedDoorDefinition.PowerConsumptionIdle;
advancedDoorDefinition.PowerConsumptionMoving = myAdvancedDoorDefinition.PowerConsumptionMoving;
}
if (myBlockDefinition is MyAirVentDefinition myAirVentDefinition &&
blockDefinition is AirVentDefinition airVentDefinition)
{
airVentDefinition.StandbyPowerConsumption = myAirVentDefinition.StandbyPowerConsumption;
airVentDefinition.OperationalPowerConsumption = myAirVentDefinition.OperationalPowerConsumption;
airVentDefinition.VentilationCapacityPerSecond = myAirVentDefinition.VentilationCapacityPerSecond;
}
if (myBlockDefinition is MyProductionBlockDefinition myProductionBlockDefinition &&
blockDefinition is ProductionBlockDefinition productionBlockDefinition)
{
productionBlockDefinition.InventoryMaxVolume = myProductionBlockDefinition.InventoryMaxVolume;
productionBlockDefinition.StandbyPowerConsumption = myProductionBlockDefinition.StandbyPowerConsumption;
productionBlockDefinition.OperationalPowerConsumption = myProductionBlockDefinition.OperationalPowerConsumption;
}
if (myBlockDefinition is MyAssemblerDefinition myAssemblerDefinition &&
blockDefinition is AssemblerDefinition assemblerDefinition)
{
assemblerDefinition.AssemblySpeed = myAssemblerDefinition.AssemblySpeed;
}
if (myBlockDefinition is MyBatteryBlockDefinition myBatteryBlockDefinition &&
blockDefinition is BatteryBlockDefinition batteryBlockDefinition)
{
batteryBlockDefinition.MaxStoredPower = myBatteryBlockDefinition.MaxStoredPower;
batteryBlockDefinition.InitialStoredPowerRatio = myBatteryBlockDefinition.InitialStoredPowerRatio;
batteryBlockDefinition.RequiredPowerInput = myBatteryBlockDefinition.RequiredPowerInput;
batteryBlockDefinition.AdaptibleInput = myBatteryBlockDefinition.AdaptibleInput;
}
if (myBlockDefinition is MyBeaconDefinition myBeaconDefinition &&
blockDefinition is BeaconDefinition beaconDefinition)
{
beaconDefinition.MaxBroadcastRadius = myBeaconDefinition.MaxBroadcastRadius;
beaconDefinition.MaxBroadcastPowerDrainkW = myBeaconDefinition.MaxBroadcastPowerDrainkW;
}
if (myBlockDefinition is MyButtonPanelDefinition myButtonPanelDefinition &&
blockDefinition is ButtonPanelDefinition buttonPanelDefinition)
{
buttonPanelDefinition.ButtonCount = myButtonPanelDefinition.ButtonCount;
}
if (myBlockDefinition is MyCameraBlockDefinition myCameraBlockDefinition &&
blockDefinition is CameraBlockDefinition cameraBlockDefinition)
{
cameraBlockDefinition.RequiredPowerInput = myCameraBlockDefinition.RequiredPowerInput;
cameraBlockDefinition.RequiredChargingInput = myCameraBlockDefinition.RequiredChargingInput;
cameraBlockDefinition.MinFov = myCameraBlockDefinition.MinFov;
cameraBlockDefinition.MaxFov = myCameraBlockDefinition.MaxFov;
cameraBlockDefinition.RaycastConeLimit = myCameraBlockDefinition.RaycastConeLimit;
cameraBlockDefinition.RaycastDistanceLimit = myCameraBlockDefinition.RaycastDistanceLimit;
cameraBlockDefinition.RaycastTimeMultiplier = myCameraBlockDefinition.RaycastTimeMultiplier;
}
if (myBlockDefinition is MyShipControllerDefinition myShipControllerDefinition &&
blockDefinition is ShipControllerDefinition shipControllerDefinition)
{
shipControllerDefinition.EnableFirstPerson = myShipControllerDefinition.EnableFirstPerson;
shipControllerDefinition.EnableShipControl = myShipControllerDefinition.EnableShipControl;
shipControllerDefinition.EnableBuilderCockpit = myShipControllerDefinition.EnableBuilderCockpit;
shipControllerDefinition.IsDefault3rdView = myShipControllerDefinition.IsDefault3rdView;
}
if (myBlockDefinition is MyCockpitDefinition myCockpitDefinition &&
blockDefinition is CockpitDefinition cockpitDefinition)
{
cockpitDefinition.OxygenCapacity = myCockpitDefinition.OxygenCapacity;
cockpitDefinition.IsPressurized = myCockpitDefinition.IsPressurized;
cockpitDefinition.HasInventory = myCockpitDefinition.HasInventory;
}
if (myBlockDefinition is MyConveyorSorterDefinition myConveyorSorterDefinition &&
blockDefinition is ConveyorSorterDefinition conveyorSorterDefinition)
{
conveyorSorterDefinition.PowerInput = myConveyorSorterDefinition.PowerInput;
}
if (myBlockDefinition is MyCryoChamberDefinition myCryoChamberDefinition &&
blockDefinition is CryoChamberDefinition cryoChamberDefinition)
{
cryoChamberDefinition.IdlePowerConsumption = myCryoChamberDefinition.IdlePowerConsumption;
}
if (myBlockDefinition is MyDecoyDefinition myDecoyDefinition &&
blockDefinition is DecoyDefinition decoyDefinition)
{
decoyDefinition.LightningRodRadiusLarge = myDecoyDefinition.LightningRodRadiusLarge;
decoyDefinition.LightningRodRadiusSmall = myDecoyDefinition.LightningRodRadiusSmall;
}
if (myBlockDefinition is MyDoorDefinition myDoorDefinition &&
blockDefinition is DoorDefinition doorDefinition)
{
doorDefinition.MaxOpen = myDoorDefinition.MaxOpen;
doorDefinition.OpeningSpeed = myDoorDefinition.OpeningSpeed;
}
if (myBlockDefinition is MyExhaustBlockDefinition myExhaustBlockDefinition &&
blockDefinition is ExhaustBlockDefinition exhaustBlockDefinition)
{
exhaustBlockDefinition.RequiredPowerInput = myExhaustBlockDefinition.RequiredPowerInput;
}
if (myBlockDefinition is MyFueledPowerProducerDefinition myFueledPowerProducerDefinition &&
blockDefinition is FueledPowerProducerDefinition fueledPowerProducerDefinition)
{
fueledPowerProducerDefinition.FuelProductionToCapacityMultiplier = myFueledPowerProducerDefinition.FuelProductionToCapacityMultiplier;
}
if (myBlockDefinition is MyGasFueledPowerProducerDefinition myGasFueledPowerProducerDefinition &&
blockDefinition is GasFueledPowerProducerDefinition gasFueledPowerProducerDefinition)
{
gasFueledPowerProducerDefinition.FuelCapacity = myGasFueledPowerProducerDefinition.FuelCapacity;
}
if (myBlockDefinition is MyGasTankDefinition myGasTankDefinition &&
blockDefinition is GasTankDefinition gasTankDefinition)
{
gasTankDefinition.Capacity = myGasTankDefinition.Capacity;
}
if (myBlockDefinition is MyGravityGeneratorBaseDefinition myGravityGeneratorBaseDefinition &&
blockDefinition is GravityGeneratorBaseDefinition gravityGeneratorBaseDefinition)
{
gravityGeneratorBaseDefinition.MinGravityAcceleration = myGravityGeneratorBaseDefinition.MinGravityAcceleration;
gravityGeneratorBaseDefinition.MaxGravityAcceleration = myGravityGeneratorBaseDefinition.MaxGravityAcceleration;
}
if (myBlockDefinition is MyGravityGeneratorDefinition myGravityGeneratorDefinition &&
blockDefinition is GravityGeneratorDefinition gravityGeneratorDefinition)
{
gravityGeneratorDefinition.RequiredPowerInput = myGravityGeneratorDefinition.RequiredPowerInput;
}
if (myBlockDefinition is MyGravityGeneratorSphereDefinition myGravityGeneratorSphereDefinition &&
blockDefinition is GravityGeneratorSphereDefinition gravityGeneratorSphereDefinition)
{
gravityGeneratorSphereDefinition.MinRadius = myGravityGeneratorSphereDefinition.MinRadius;
gravityGeneratorSphereDefinition.MaxRadius = myGravityGeneratorSphereDefinition.MaxRadius;
gravityGeneratorSphereDefinition.BasePowerInput = myGravityGeneratorSphereDefinition.BasePowerInput;
gravityGeneratorSphereDefinition.ConsumptionPower = myGravityGeneratorSphereDefinition.ConsumptionPower;
}
if (myBlockDefinition is MyGyroDefinition myGyroDefinition &&
blockDefinition is GyroDefinition gyroDefinition)
{
gyroDefinition.ForceMagnitude = myGyroDefinition.ForceMagnitude;
gyroDefinition.RequiredPowerInput = myGyroDefinition.RequiredPowerInput;
}
if (myBlockDefinition is MySoundBlockDefinition mySoundBlockDefinition &&
blockDefinition is SoundBlockDefinition soundBlockDefinition)
{
soundBlockDefinition.MinRange = mySoundBlockDefinition.MinRange;
soundBlockDefinition.MaxRange = mySoundBlockDefinition.MaxRange;
soundBlockDefinition.MaxLoopPeriod = mySoundBlockDefinition.MaxLoopPeriod;
soundBlockDefinition.EmitterNumber = mySoundBlockDefinition.EmitterNumber;
soundBlockDefinition.LoopUpdateThreshold = mySoundBlockDefinition.LoopUpdateThreshold;
}
if (myBlockDefinition is MyJumpDriveDefinition myJumpDriveDefinition &&
blockDefinition is JumpDriveDefinition jumpDriveDefinition)
{
jumpDriveDefinition.RequiredPowerInput = myJumpDriveDefinition.RequiredPowerInput;
jumpDriveDefinition.PowerNeededForJump = myJumpDriveDefinition.PowerNeededForJump;
jumpDriveDefinition.MinJumpDistance = myJumpDriveDefinition.MinJumpDistance;
jumpDriveDefinition.MaxJumpDistance = myJumpDriveDefinition.MaxJumpDistance;
jumpDriveDefinition.MaxJumpMass = myJumpDriveDefinition.MaxJumpMass;
}
if (myBlockDefinition is MyLandingGearDefinition myLandingGearDefinition &&
blockDefinition is LandingGearDefinition landingGearDefinition)
{
landingGearDefinition.MaxLockSeparatingVelocity = myLandingGearDefinition.MaxLockSeparatingVelocity;
}
if (myBlockDefinition is MyWeaponBlockDefinition myWeaponBlockDefinition &&
blockDefinition is WeaponBlockDefinition weaponBlockDefinition)
{
weaponBlockDefinition.InventoryMaxVolume = myWeaponBlockDefinition.InventoryMaxVolume;
weaponBlockDefinition.InventoryFillFactorMin = myWeaponBlockDefinition.InventoryFillFactorMin;
}
if (myBlockDefinition is MyLightingBlockDefinition myLightingBlockDefinition &&
blockDefinition is LightingBlockDefinition lightingBlockDefinition)
{
lightingBlockDefinition.RequiredPowerInput = myLightingBlockDefinition.RequiredPowerInput;
lightingBlockDefinition.ReflectorConeDegrees = myLightingBlockDefinition.ReflectorConeDegrees;
}
if (myBlockDefinition is MyMechanicalConnectionBlockBaseDefinition myMechanicalConnectionBlockBaseDefinition &&
blockDefinition is MechanicalConnectionBlockBaseDefinition mechanicalConnectionBlockBaseDefinition)
{
mechanicalConnectionBlockBaseDefinition.SafetyDetach = myMechanicalConnectionBlockBaseDefinition.SafetyDetach;
mechanicalConnectionBlockBaseDefinition.SafetyDetachMin = myMechanicalConnectionBlockBaseDefinition.SafetyDetachMin;
mechanicalConnectionBlockBaseDefinition.SafetyDetachMax = myMechanicalConnectionBlockBaseDefinition.SafetyDetachMax;
}
if (myBlockDefinition is MyMedicalRoomDefinition myMedicalRoomDefinition &&
blockDefinition is MedicalRoomDefinition medicalRoomDefinition)
{
medicalRoomDefinition.RespawnAllowed = myMedicalRoomDefinition.RespawnAllowed;
medicalRoomDefinition.HealingAllowed = myMedicalRoomDefinition.HealingAllowed;
medicalRoomDefinition.RefuelAllowed = myMedicalRoomDefinition.RefuelAllowed;
medicalRoomDefinition.SuitChangeAllowed = myMedicalRoomDefinition.SuitChangeAllowed;
medicalRoomDefinition.CustomWardrobesEnabled = myMedicalRoomDefinition.CustomWardrobesEnabled;
medicalRoomDefinition.ForceSuitChangeOnRespawn = myMedicalRoomDefinition.ForceSuitChangeOnRespawn;
medicalRoomDefinition.SpawnWithoutOxygenEnabled = myMedicalRoomDefinition.SpawnWithoutOxygenEnabled;
medicalRoomDefinition.WardrobeCharacterOffsetLength = myMedicalRoomDefinition.WardrobeCharacterOffsetLength;
}
if (myBlockDefinition is MyMergeBlockDefinition myMergeBlockDefinition &&
blockDefinition is MergeBlockDefinition mergeBlockDefinition)
{
mergeBlockDefinition.Strength = myMergeBlockDefinition.Strength;
}
if (myBlockDefinition is MyOreDetectorDefinition myOreDetectorDefinition &&
blockDefinition is OreDetectorDefinition oreDetectorDefinition)
{
oreDetectorDefinition.MaximumRange = myOreDetectorDefinition.MaximumRange;
}
if (myBlockDefinition is MyOxygenFarmDefinition myOxygenFarmDefinition &&
blockDefinition is OxygenFarmDefinition oxygenFarmDefinition)
{
oxygenFarmDefinition.IsTwoSided = myOxygenFarmDefinition.IsTwoSided;
oxygenFarmDefinition.PanelOffset = myOxygenFarmDefinition.PanelOffset;
oxygenFarmDefinition.MaxGasOutput = myOxygenFarmDefinition.MaxGasOutput;
oxygenFarmDefinition.OperationalPowerConsumption = myOxygenFarmDefinition.OperationalPowerConsumption;
}
if (myBlockDefinition is MyOxygenGeneratorDefinition myOxygenGeneratorDefinition &&
blockDefinition is OxygenGeneratorDefinition oxygenGeneratorDefinition)
{
oxygenGeneratorDefinition.IceConsumptionPerSecond = myOxygenGeneratorDefinition.IceConsumptionPerSecond;
oxygenGeneratorDefinition.IsOxygenOnly = myOxygenGeneratorDefinition.IsOxygenOnly;
oxygenGeneratorDefinition.InventoryFillFactorMin = myOxygenGeneratorDefinition.InventoryFillFactorMin;
oxygenGeneratorDefinition.InventoryFillFactorMax = myOxygenGeneratorDefinition.InventoryFillFactorMax;
oxygenGeneratorDefinition.FuelPullAmountFromConveyorInMinutes = myOxygenGeneratorDefinition.FuelPullAmountFromConveyorInMinutes;
}
if (myBlockDefinition is MyParachuteDefinition myParachuteDefinition &&
blockDefinition is ParachuteDefinition parachuteDefinition)
{
parachuteDefinition.PowerConsumptionIdle = myParachuteDefinition.PowerConsumptionIdle;
parachuteDefinition.PowerConsumptionMoving = myParachuteDefinition.PowerConsumptionMoving;
parachuteDefinition.DragCoefficient = myParachuteDefinition.DragCoefficient;
parachuteDefinition.ReefAtmosphereLevel = myParachuteDefinition.ReefAtmosphereLevel;
parachuteDefinition.MinimumAtmosphereLevel = myParachuteDefinition.MinimumAtmosphereLevel;
parachuteDefinition.RadiusMultiplier = myParachuteDefinition.RadiusMultiplier;
}
if (myBlockDefinition is MyPistonBaseDefinition myPistonBaseDefinition &&
blockDefinition is PistonBaseDefinition pistonBaseDefinition)
{
pistonBaseDefinition.Minimum = myPistonBaseDefinition.Minimum;
pistonBaseDefinition.Maximum = myPistonBaseDefinition.Maximum;
pistonBaseDefinition.MaxVelocity = myPistonBaseDefinition.MaxVelocity;
pistonBaseDefinition.RequiredPowerInput = myPistonBaseDefinition.RequiredPowerInput;
pistonBaseDefinition.MaxImpulse = myPistonBaseDefinition.MaxImpulse;
pistonBaseDefinition.DefaultMaxImpulseAxis = myPistonBaseDefinition.DefaultMaxImpulseAxis;
pistonBaseDefinition.DefaultMaxImpulseNonAxis = myPistonBaseDefinition.DefaultMaxImpulseNonAxis;
pistonBaseDefinition.UnsafeImpulseThreshold = myPistonBaseDefinition.UnsafeImpulseThreshold;
}
if (myBlockDefinition is MyProjectorDefinition myProjectorDefinition &&
blockDefinition is ProjectorDefinition projectorDefinition)
{
projectorDefinition.RequiredPowerInput = myProjectorDefinition.RequiredPowerInput;
projectorDefinition.AllowScaling = myProjectorDefinition.AllowScaling;
projectorDefinition.AllowWelding = myProjectorDefinition.AllowWelding;
projectorDefinition.IgnoreSize = myProjectorDefinition.IgnoreSize;
projectorDefinition.RotationAngleStepDeg = myProjectorDefinition.RotationAngleStepDeg;
}
if (myBlockDefinition is MyRadioAntennaDefinition myRadioAntennaDefinition &&
blockDefinition is RadioAntennaDefinition radioAntennaDefinition)
{
radioAntennaDefinition.MaxBroadcastRadius = myRadioAntennaDefinition.MaxBroadcastRadius;
radioAntennaDefinition.LightningRodRadiusLarge = myRadioAntennaDefinition.LightningRodRadiusLarge;
radioAntennaDefinition.LightningRodRadiusSmall = myRadioAntennaDefinition.LightningRodRadiusSmall;
}
}
public void SendUndefineBlock(BlockDefinition def)
{
Send(Packet.UndefineBlock(def, player.hasExtBlocks));
}
private void Move()
{
bool collision = false;
int loop = 0;
do
{
BoundingBox playerBox = new BoundingBox(
new Vector3(
player.GlobalPosition.X - playerRadius,
player.GlobalPosition.Y - playerRadius,
player.GlobalPosition.Z),
new Vector3(
player.GlobalPosition.X + playerRadius,
player.GlobalPosition.Y + playerRadius,
player.GlobalPosition.Z + playerHeight));
collision = false;
float min = 1f;
Axis minAxis = Axis.None;
foreach (var pos in blocks.Keys)
{
BlockDefinition block = blocks[pos];
if (block == null)
{
continue;
}
Axis? localAxis;
float?moveFactor = block.Intersect(pos, playerBox, move, out localAxis);
if (moveFactor.HasValue && moveFactor.Value < min)
{
collision = true;
min = moveFactor.Value;
minAxis = localAxis.Value;
}
}
player += (move * min);
move *= (1f - min);
switch (minAxis)
{
case Axis.X:
player += new Vector3(move.X > 0 ? -gap : gap, 0, 0);
move.X = 0f;
break;
case Axis.Y:
player += new Vector3(0, move.Y > 0 ? -gap : gap, 0);
move.Y = 0f;
break;
case Axis.Z:
player += new Vector3(0, 0, move.Z > 0 ? -gap : gap);
move.Z = 0f;
break;
}
// Koordinate normalisieren (Rundwelt)
// player.NormalizeChunkIndexXY(planet.Size);
loop++;
}while (collision && loop < 3);
}
public OverlayBlockDefinitionItemModel(BlockDefinition b, IdeCollection <IdeBaseItem> source) : base(source) // load overlay
{
_def = b;
}
public void ExportMesh(ComputeBuffer buffer, uint vCount, string name)
{
Vertex_GR[] output = new Vertex_GR[vCount];
buffer.GetData(output);
indBuffer.GetData(_ind);
vCount = _ind[0];
StringBuilder sb = new StringBuilder();
sb.Append("mtllib ").Append("material.mtl").Append("\n");
//sb.Append("usemtl ").Append("BlockAtlas").Append("\n");
sb.Append("usemtl ").Append("RGB444").Append("\n");
//sb.Append("g ").Append("Chunk").Append("\n");
sb.Append("o\n");
sb.Append("\n");
foreach (Vertex_GR v in output)
{
sb.Append(string.Format("vn {0} {1} {2}\n", v.normal.x, v.normal.y, v.normal.z));
}
sb.Append("\n");
foreach (Vertex_GR v in output)
{
if (v.block.id < 0 || v.block.id > 65535)
{
Debug.LogError(v.block.id);
}
Vector2 uv = Vector2.zero;
if (v.block.id == 0xffff)
{
int r = ((v.block.meta >> 12) & 0xf);
int g = ((v.block.meta >> 8) & 0xf);
int b = ((v.block.meta >> 4) & 0xf);
uv.x = ((r * 4 + b / 4) + 0.5f) / 64.0f;
uv.y = ((g * 4 + b % 4) + 0.5f) / 64.0f;
}
else
{
BlockDefinition def = Globals.voxelisMain.Instance.globalSettings.blockRegistryTable.blockDefinitions[v.block.id];
Vector2 uv_org = Vector2.zero, uv_size = Vector2.zero;
if (def != null)
{
uv_org = new Vector2(def.uvw.x, def.uvw.y);
uv_size = def.uvSize;
}
uv = uv_org + v.uv * uv_size;
}
sb.Append(string.Format("vt {0} {1}\n", uv.x, uv.y));
//sb.Append(string.Format("vt {0} {1}\n", v.uv.x, v.uv.y));
}
sb.Append("\n");
foreach (Vertex_GR v in output)
{
sb.Append(string.Format("v {0} {1} {2}\n", v.position.x, v.position.y, v.position.z));
}
sb.Append("\n");
for (int i = 0; i < vCount; i += 3)
{
sb.Append(string.Format("f {0}/{0}/{0} {1}/{1}/{1} {2}/{2}/{2}\n",
i + 1, i + 2, i + 3));
}
using (StreamWriter sw = new StreamWriter(name))
{
sw.Write(sb.ToString());
}
// Material
if (!MaterialExported)
{
Texture2D tex = new Texture2D(
Globals.voxelisMain.Instance.globalSettings.blockRegistryTable.BlockTexArray.width,
Globals.voxelisMain.Instance.globalSettings.blockRegistryTable.BlockTexArray.height,
Globals.voxelisMain.Instance.globalSettings.blockRegistryTable.BlockTexArray.format,
Globals.voxelisMain.Instance.globalSettings.blockRegistryTable.BlockTexArray.mipmapCount, false);
Graphics.CopyTexture(Globals.voxelisMain.Instance.globalSettings.blockRegistryTable.BlockTexArray, 0, tex, 0);
File.WriteAllBytes("ExportedMeshes/atlas.png", tex.EncodeToPNG());
// RGB444 colors
Texture2D texRGB = new Texture2D(64, 64);
for (int r = 0; r < 16; r++)
{
for (int g = 0; g < 16; g++)
{
for (int b = 0; b < 16; b++)
{
texRGB.SetPixel(r * 4 + b / 4, g * 4 + b % 4, new Color(r / 16.0f, g / 16.0f, b / 16.0f));
}
}
}
File.WriteAllBytes("ExportedMeshes/rgb.png", texRGB.EncodeToPNG());
sb = new StringBuilder();
//sb.Append("newmtl BlockAtlas\nKa 1.0 1.0 1.0\nKd 1.0 1.0 1.0\nKs 0.0 0.0 0.0\nmap_Ka atlas.png\nmap_Kd atlas.png\nmap_Ks atlas.png");
sb.Append("newmtl BlockAtlas\nKa 0.0 0.0 0.0\nKd 1.0 1.0 1.0\nKs 0.0 0.0 0.0\nmap_Kd atlas.png\n\n");
sb.Append("newmtl RGB444\nKa 0.0 0.0 0.0\nKd 1.0 1.0 1.0\nKs 0.0 0.0 0.0\nmap_Kd rgb.png");
using (StreamWriter sw = new StreamWriter("ExportedMeshes/material.mtl"))
{
sw.Write(sb.ToString());
}
MaterialExported = true;
}
}
public BoxLayoutBlock(View hostView, Node parentNode, BlockBase parentBlock, BlockDefinition definition, FieldList content, bool isRoot)
: base(hostView, parentNode, parentBlock, definition, content, isRoot)
{
UnpackDefinition();
UnpackContent();
}
static void CopyHandler(Player p, Level lvl, string[] parts, CommandData data,
bool global, string cmd)
{
if (parts.Length < 2)
{
Help(p, cmd); return;
}
int min, max;
if (!CheckRawBlocks(p, parts[1], out min, out max, true))
{
return;
}
BlockID dst;
BlockDefinition[] defs = global ? BlockDefinition.GlobalDefs : lvl.CustomBlockDefs;
if (parts.Length > 2)
{
if (!CheckBlock(p, parts[2], out dst))
{
return;
}
if (parts.Length > 3)
{
string coloredMap = null;
defs = GetDefs(p, data, parts[3], ref coloredMap);
if (defs == null)
{
return;
}
}
}
else
{
dst = GetFreeBlock(p, global, lvl, cmd);
if (dst == Block.Invalid)
{
return;
}
}
bool changed = false;
for (int i = min; i <= max && Block.ToRaw(dst) <= Block.MaxRaw; i++, dst++)
{
BlockID src = Block.FromRaw((BlockID)i);
if (!DoCopy(p, lvl, global, cmd, false, defs[src], src, dst))
{
continue;
}
string scope = global ? "global" : "level";
p.Message("Duplicated the {0} custom block with id \"{1}\" to \"{2}\".",
scope, i, Block.ToRaw(dst));
changed = true;
}
if (changed)
{
BlockDefinition.Save(global, lvl);
}
}
static int Order(BlockDefinition def)
{
return(def.InventoryOrder == -1 ? def.RawID : def.InventoryOrder);
}
static string FormatBlock(BlockDefinition def)
{
return("Custom block &T" + def.RawID + " &Shas name &T" + def.Name);
}
public void Cleanup()
{
block = null;
}
static bool DoEdit(Player p, Level lvl, BlockID block, string[] parts,
bool global, string cmd)
{
BlockDefinition[] defs = global ? BlockDefinition.GlobalDefs : lvl.CustomBlockDefs;
BlockDefinition def = defs[block], globalDef = BlockDefinition.GlobalDefs[block];
if (def == null && block < Block.CpeCount)
{
def = DefaultSet.MakeCustomBlock(block);
UpdateBlock(p, lvl, def, global);
}
if (def != null && !global && def == globalDef)
{
def = globalDef.Copy();
UpdateBlock(p, lvl, def, global);
}
if (!ExistsInScope(def, block, global))
{
MessageNoBlock(p, block, global, cmd); return(false);
}
string value = parts[3], blockName = def.Name;
bool temp = false, changedFallback = false;
string arg = MapPropertyName(parts[2].ToLower());
switch (arg)
{
case "name":
def.Name = value; break;
case "collide":
if (!EditByte(p, value, "Collide type", ref def.CollideType, arg))
{
return(false);
}
break;
case "speed":
if (!CommandParser.GetReal(p, value, "Movement speed", ref def.Speed, 0.25f, 3.96f))
{
SendEditHelp(p, arg); return(false);
}
break;
case "toptex":
if (!EditUShort(p, value, "Top texture", ref def.TopTex, arg))
{
return(false);
}
break;
case "alltex":
if (!EditUShort(p, value, "All textures", ref def.RightTex, arg))
{
return(false);
}
def.SetAllTex(def.RightTex);
break;
case "sidetex":
if (!EditUShort(p, value, "Side texture", ref def.RightTex, arg))
{
return(false);
}
def.SetSideTex(def.RightTex);
break;
case "lefttex":
if (!EditUShort(p, value, "Left texture", ref def.LeftTex, arg))
{
return(false);
}
break;
case "righttex":
if (!EditUShort(p, value, "Right texture", ref def.RightTex, arg))
{
return(false);
}
break;
case "fronttex":
if (!EditUShort(p, value, "Front texture", ref def.FrontTex, arg))
{
return(false);
}
break;
case "backtex":
if (!EditUShort(p, value, "Back texture", ref def.BackTex, arg))
{
return(false);
}
break;
case "bottomtex":
if (!EditUShort(p, value, "Bottom texture", ref def.BottomTex, arg))
{
return(false);
}
break;
case "blockslight":
if (!CommandParser.GetBool(p, value, ref temp))
{
SendEditHelp(p, arg); return(false);
}
def.BlocksLight = temp;
break;
case "sound":
if (!EditByte(p, value, "Walk sound", ref def.WalkSound, arg))
{
return(false);
}
break;
case "fullbright":
if (!CommandParser.GetBool(p, value, ref temp))
{
SendEditHelp(p, arg); return(false);
}
def.FullBright = temp;
break;
case "shape":
if (!CommandParser.GetBool(p, value, ref temp))
{
SendEditHelp(p, arg); return(false);
}
def.Shape = temp ? (byte)0 : def.MaxZ;
break;
case "blockdraw":
if (!EditByte(p, value, "Block draw", ref def.BlockDraw, arg))
{
return(false);
}
break;
case "min":
if (!ParseCoords(p, value, ref def.MinX, ref def.MinY, ref def.MinZ))
{
SendEditHelp(p, arg); return(false);
}
break;
case "max":
if (!ParseCoords(p, value, ref def.MaxX, ref def.MaxY, ref def.MaxZ))
{
SendEditHelp(p, arg); return(false);
}
break;
case "fogdensity":
if (!EditByte(p, value, "Fog density", ref def.FogDensity, arg))
{
return(false);
}
break;
case "fogcolor":
ColorDesc rgb = default(ColorDesc);
if (!CommandParser.GetHex(p, value, ref rgb))
{
return(false);
}
def.FogR = rgb.R; def.FogG = rgb.G; def.FogB = rgb.B;
break;
case "fallback":
byte fallback = GetFallback(p, value);
if (fallback == Block.Invalid)
{
return(false);
}
changedFallback = true;
value = Block.GetName(p, fallback);
def.FallBack = fallback; break;
case "order":
int order = 0;
if (!CommandParser.GetInt(p, value, "Inventory order", ref order, 0, Block.MaxRaw))
{
SendEditHelp(p, arg); return(false);
}
// Don't let multiple blocks be assigned to same order
if (order != def.RawID && order != 0)
{
for (int i = 0; i < defs.Length; i++)
{
if (defs[i] == null || defs[i].InventoryOrder != order)
{
continue;
}
p.Message("Block {0} already had order {1}", defs[i].Name, order);
return(false);
}
}
def.InventoryOrder = order == def.RawID ? -1 : order;
BlockDefinition.UpdateOrder(def, global, lvl);
p.Message("Set inventory order for {0} to {1}", blockName,
order == def.RawID ? "default" : order.ToString());
return(true);
default:
p.Message("Unrecognised property: " + arg); return(false);
}
p.Message("Set {0} for {1} to {2}", arg, blockName, value);
BlockDefinition.Add(def, defs, lvl);
if (changedFallback)
{
BlockDefinition.UpdateFallback(global, def.GetBlock(), lvl);
}
return(true);
}
public ApplicationBarBlock(View hostView, Node parentNode, BlockBase parentBlock, BlockDefinition definition, FieldList content, bool isRoot)
: base(hostView, parentNode, parentBlock, definition, content, isRoot)
{
buttons = new List <ApplicationBarButtonBlock>();
menuItems = new List <ApplicationBarMenuItemBlock>();
preparedButtons = new List <ApplicationBarIconButton>();
preparedMenuItems = new List <ApplicationBarMenuItem>();
UnpackDefinition();
UnpackContent();
}
void DefineBlockStep(Player p, string value) {
string opt = value.ToLower();
if (opt == "revert" && step > 2) {
step--;
SendStepHelp(p, step); return;
}
if (step == 2) {
bd.Name = value;
step++;
} else if (step == 3) {
if (value == "0" || value == "1" || value == "2") {
bd.CollideType = byte.Parse(value);
step++;
}
} else if (step == 4) {
if (float.TryParse(value, out bd.Speed) && bd.Speed >= 0.25f && bd.Speed <= 3.96f)
step++;
} else if (step == 5) {
if (byte.TryParse(value, out bd.TopTex))
step++;
} else if (step == 6) {
if (byte.TryParse(value, out bd.SideTex))
step++;
} else if (step == 7) {
if (byte.TryParse(value, out bd.BottomTex))
step++;
} else if (step == 8) {
if (value == "0" || value == "1") {
bd.BlocksLight = value == "0";
step++;
}
} else if (step == 9) {
bool result = byte.TryParse(value, out bd.WalkSound);
if (result && bd.WalkSound <= 11)
step++;
} else if (step == 10) {
if (value == "0" || value == "1") {
bd.FullBright = value != "0";
step++;
}
} else if (step == 11) {
bool result = byte.TryParse(value, out bd.BlockDraw);
if (result && bd.BlockDraw >= 0 && bd.BlockDraw <= 3)
step++;
} else if (step == 12) {
if (value == "0" || value == "1") {
bd.Shape = value == "0" ? (byte)0 : (byte)16;
step = bd.Shape == 0 ? 15 : 13;
}
} else if (step == 13) {
if (ParseCoords(value, out bd.MinX, out bd.MinY, out bd.MinZ))
step++;
} else if (step == 14) {
if (ParseCoords(value, out bd.MaxX, out bd.MaxY, out bd.MaxZ))
step++;
bd.Shape = bd.MaxY;
} else if (step == 15) {
if (byte.TryParse(value, out bd.FogDensity))
step = bd.FogDensity == 0 ? 19 : 16;
} else if (step == 16) {
if (byte.TryParse(value, out bd.FogR))
step++;
} else if (step == 17) {
if (byte.TryParse(value, out bd.FogG))
step++;
} else if (step == 18) {
if (byte.TryParse(value, out bd.FogB))
step++;
} else if (step == 19) {
if (Block.Byte(value) == Block.Zero) {
SendStepHelp(p, step); return;
}
bd.FallBack = Block.Byte(value);
// in case the list is modified before we finish the command.
if (BlockDefinition.GlobalDefinitions[bd.BlockID] != null) {
bd.BlockID = GetFreeId();
if (bd.BlockID == Block.Zero) {
Player.SendMessage(p, "There are no custom block ids left, " +
"you must /gb remove a custom block first.");
return;
}
}
Player.SendMessage(p, "Created a new custom block " + bd.Name + "(" + bd.BlockID + ")");
BlockDefinition.AddGlobal(bd);
BlockDefinition.SaveGlobal("blocks.json");
bd = null;
return;
}
SendStepHelp(p, step);
}
