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); }