github.com/df-mc/dragonfly@v0.9.13/server/block/slab_type.go (about)

     1  package block
     2  
     3  import (
     4  	"github.com/df-mc/dragonfly/server/world"
     5  )
     6  
     7  // encodeSlabBlock encodes the provided block in to an identifier and meta value that can be used to encode the slab.
     8  func encodeSlabBlock(block world.Block) (id, slabType string, meta int16) {
     9  	switch block := block.(type) {
    10  	// TODO: Copper
    11  	case Andesite:
    12  		if block.Polished {
    13  			return "polished_andesite", "stone_slab_type_3", 2
    14  		}
    15  		return "andesite", "stone_slab_type_3", 3
    16  	case Blackstone:
    17  		if block.Type == NormalBlackstone() {
    18  			return "blackstone", "", 0
    19  		} else if block.Type == PolishedBlackstone() {
    20  			return "polished_blackstone", "", 0
    21  		}
    22  	case Bricks:
    23  		return "brick", "stone_slab_type", 4
    24  	case Cobblestone:
    25  		if block.Mossy {
    26  			return "mossy_cobblestone", "stone_slab_type_2", 5
    27  		}
    28  		return "cobblestone", "stone_slab_type", 3
    29  	case Deepslate:
    30  		if block.Type == CobbledDeepslate() {
    31  			return "cobbled_deepslate", "", 0
    32  		} else if block.Type == PolishedDeepslate() {
    33  			return "polished_deepslate", "", 0
    34  		}
    35  	case DeepslateBricks:
    36  		if !block.Cracked {
    37  			return "deepslate_brick", "", 0
    38  		}
    39  	case DeepslateTiles:
    40  		if !block.Cracked {
    41  			return "deepslate_tile", "", 0
    42  		}
    43  	case Diorite:
    44  		if block.Polished {
    45  			return "polished_diorite", "stone_slab_type_3", 5
    46  		}
    47  		return "diorite", "stone_slab_type_3", 4
    48  	case EndBricks:
    49  		return "end_stone_brick", "stone_slab_type_3", 0
    50  	case Granite:
    51  		if block.Polished {
    52  			return "polished_granite", "stone_slab_type_3", 7
    53  		}
    54  		return "granite", "stone_slab_type_3", 6
    55  	case MudBricks:
    56  		return "mud_brick", "", 0
    57  	case NetherBricks:
    58  		if block.Type == RedNetherBricks() {
    59  			return "nether_brick", "stone_slab_type", 7
    60  		}
    61  		return "red_nether_brick", "stone_slab_type_2", 7
    62  	case Planks:
    63  		switch block.Wood {
    64  		case OakWood(), SpruceWood(), BirchWood(), JungleWood(), AcaciaWood(), DarkOakWood():
    65  			return block.Wood.String(), "wood_type", int16(block.Wood.Uint8())
    66  		default:
    67  			return block.Wood.String(), "", 0
    68  		}
    69  	case PolishedBlackstoneBrick:
    70  		if !block.Cracked {
    71  			return "polished_blackstone_brick", "", 0
    72  		}
    73  	case Prismarine:
    74  		switch block.Type {
    75  		case NormalPrismarine():
    76  			return "prismarine_rough", "stone_slab_type_2", 2
    77  		case DarkPrismarine():
    78  			return "prismarine_dark", "stone_slab_type_2", 3
    79  		case BrickPrismarine():
    80  			return "prismarine_brick", "stone_slab_type_2", 4
    81  		}
    82  		panic("invalid prismarine type")
    83  	case Purpur:
    84  		return "purpur", "stone_slab_type_2", 1
    85  	case Quartz:
    86  		if block.Smooth {
    87  			return "smooth_quartz", "stone_slab_type_4", 1
    88  		}
    89  		return "quartz", "stone_slab_type", 6
    90  	case Sandstone:
    91  		switch block.Type {
    92  		case NormalSandstone():
    93  			if block.Red {
    94  				return "red_sandstone", "stone_slab_type_2", 0
    95  			}
    96  			return "sandstone", "stone_slab_type", 1
    97  		case CutSandstone():
    98  			if block.Red {
    99  				return "cut_red_sandstone", "stone_slab_type_4", 4
   100  			}
   101  			return "cut_sandstone", "stone_slab_type_4", 3
   102  		case SmoothSandstone():
   103  			if block.Red {
   104  				return "smooth_red_sandstone", "stone_slab_type_3", 1
   105  			}
   106  			return "smooth_sandstone", "stone_slab_type_2", 6
   107  		}
   108  		panic("invalid sandstone type")
   109  	case Stone:
   110  		if block.Smooth {
   111  			return "smooth_stone", "stone_slab_type", 0
   112  		}
   113  		return "stone", "stone_slab_type_4", 2
   114  	case StoneBricks:
   115  		if block.Type == MossyStoneBricks() {
   116  			return "mossy_stone_brick", "stone_slab_type_4", 0
   117  		}
   118  		return "stone_brick", "stone_slab_type", 5
   119  	}
   120  	panic("invalid block used for slab")
   121  }
   122  
   123  // encodeLegacySlabId encodes a legacy slab type to its identifier.
   124  func encodeLegacySlabId(slabType string) string {
   125  	switch slabType {
   126  	case "wood_type":
   127  		return "wooden_slab"
   128  	case "stone_slab_type":
   129  		return "stone_block_slab"
   130  	case "stone_slab_type_2":
   131  		return "stone_block_slab2"
   132  	case "stone_slab_type_3":
   133  		return "stone_block_slab3"
   134  	case "stone_slab_type_4":
   135  		return "stone_block_slab4"
   136  	}
   137  	panic("invalid slab type")
   138  }
   139  
   140  // SlabBlocks returns a list of all possible blocks for a slab.
   141  func SlabBlocks() []world.Block {
   142  	b := []world.Block{
   143  		// TODO: Copper
   144  		Andesite{Polished: true},
   145  		Andesite{},
   146  		Blackstone{Type: PolishedBlackstone()},
   147  		Blackstone{},
   148  		Bricks{},
   149  		Cobblestone{Mossy: true},
   150  		Cobblestone{},
   151  		DeepslateBricks{},
   152  		DeepslateTiles{},
   153  		Deepslate{Type: CobbledDeepslate()},
   154  		Deepslate{Type: PolishedDeepslate()},
   155  		Diorite{Polished: true},
   156  		Diorite{},
   157  		EndBricks{},
   158  		Granite{Polished: true},
   159  		Granite{},
   160  		MudBricks{},
   161  		NetherBricks{Type: RedNetherBricks()},
   162  		NetherBricks{},
   163  		PolishedBlackstoneBrick{},
   164  		Purpur{},
   165  		Quartz{Smooth: true},
   166  		Quartz{},
   167  		StoneBricks{Type: MossyStoneBricks()},
   168  		StoneBricks{},
   169  		Stone{Smooth: true},
   170  		Stone{},
   171  	}
   172  	for _, p := range PrismarineTypes() {
   173  		b = append(b, Prismarine{Type: p})
   174  	}
   175  	for _, s := range SandstoneTypes() {
   176  		if s != ChiseledSandstone() {
   177  			b = append(b, Sandstone{Type: s})
   178  			b = append(b, Sandstone{Type: s, Red: true})
   179  		}
   180  	}
   181  	for _, w := range WoodTypes() {
   182  		b = append(b, Planks{Wood: w})
   183  	}
   184  	return b
   185  }