Golang Compound.Set Examples

Example #1

File: inventory.go Project: compbrain/chunkymonkey

func (inv *Inventory) MarshalNbt(tag *nbt.Compound) (err error) {
	occupiedSlots := 0
	for i := range inv.slots {
		if inv.slots[i].Count > 0 {
			occupiedSlots++
		}
	}

	itemList := &nbt.List{nbt.TagCompound, make([]nbt.ITag, 0, occupiedSlots)}
	for i := range inv.slots {
		slot := &inv.slots[i]
		if slot.Count > 0 {
			slotTag := nbt.NewCompound()
			slotTag.Set("Slot", &nbt.Byte{int8(i)})
			if err = slot.MarshalNbt(slotTag); err != nil {
				return
			}
			itemList.Value = append(itemList.Value, slotTag)
		}
	}

	tag.Set("Items", itemList)

	return nil
}

Example #2

File: block_music.go Project: huwenshu/chunkymonkey

func (music *musicTileEntity) MarshalNbt(tag *nbt.Compound) (err os.Error) {
	if err = music.tileEntity.MarshalNbt(tag); err != nil {
		return
	}

	tag.Set("id", &nbt.String{"Music"})
	tag.Set("note", &nbt.Byte{int8(music.note)})

	return nil
}

Example #3

File: block_recordplayer.go Project: huwenshu/chunkymonkey

func (recordPlayer *recordPlayerTileEntity) MarshalNbt(tag *nbt.Compound) (err os.Error) {
	if err = recordPlayer.tileEntity.MarshalNbt(tag); err != nil {
		return
	}

	tag.Set("id", &nbt.String{"RecordPlayer"})
	tag.Set("Record", &nbt.Int{recordPlayer.record})

	return nil
}

Example #4

File: object.go Project: b1naryth1ef/chunkymonkey

func (object *Object) MarshalNbt(tag nbt.Compound) (err error) {
	objTypeName, ok := ObjNameByType[object.ObjTypeId]
	if !ok {
		return errors.New("unknown object type")
	}
	if err = object.PointObject.MarshalNbt(tag); err != nil {
		return
	}
	tag.Set("id", &nbt.String{objTypeName})
	// TODO unknown fields
	return
}

Example #5

File: item.go Project: huwenshu/chunkymonkey

func (item *Item) MarshalNbt(tag *nbt.Compound) (err os.Error) {
	if err = item.PointObject.MarshalNbt(tag); err != nil {
		return
	}
	tag.Set("id", &nbt.String{"Item"})
	tag.Set("Item", &nbt.Compound{map[string]nbt.ITag{
		"id":     &nbt.Short{int16(item.ItemTypeId)},
		"Count":  &nbt.Byte{int8(item.Count)},
		"Damage": &nbt.Short{int16(item.Data)},
	}})
	return nil
}

Example #6

File: player_inventory.go Project: huwenshu/chunkymonkey

func (w *PlayerInventory) MarshalNbt(tag *nbt.Compound) (err os.Error) {
	slots := make([]nbt.ITag, 0, 0)

	// Add the holding inventory
	for i := 0; i < int(w.holding.NumSlots()); i++ {
		slot := w.holding.Slot(SlotId(i))
		if !slot.IsEmpty() {
			slotTag := nbt.NewCompound()
			slotTag.Set("Slot", &nbt.Byte{int8(i)})
			if err = slot.MarshalNbt(slotTag); err != nil {
				return
			}
			slots = append(slots, slotTag)
		}
	}

	// Add the main inventory
	for i := 0; i < int(w.main.NumSlots()); i++ {
		slot := w.main.Slot(SlotId(i))
		if !slot.IsEmpty() {
			slotTag := nbt.NewCompound()
			slotTag.Set("Slot", &nbt.Byte{int8(i + playerInvHoldingNum)})
			if err = slot.MarshalNbt(slotTag); err != nil {
				return
			}
			slots = append(slots, slotTag)
		}
	}

	// Add the armor inventory
	for i := 0; i < int(w.armor.NumSlots()); i++ {
		slot := w.armor.Slot(SlotId(i))
		if !slot.IsEmpty() {
			slotTag := nbt.NewCompound()
			slotTag.Set("Slot", &nbt.Byte{int8(i + 100)})
			if err = slot.MarshalNbt(slotTag); err != nil {
				return
			}
			slots = append(slots, slotTag)
		}
	}

	tag.Set("Inventory", &nbt.List{nbt.TagCompound, slots})

	return nil
}

Example #7

File: block_mobspawner.go Project: valtyr/chunkymonkey

func (mobSpawner *mobSpawnerTileEntity) MarshalNbt(tag *nbt.Compound) (err os.Error) {
	if err = mobSpawner.tileEntity.MarshalNbt(tag); err != nil {
		return
	}

	tag.Set("id", &nbt.String{"MobSpawner"})
	tag.Set("EntityId", &nbt.String{mobSpawner.entityMobType})
	tag.Set("Delay", &nbt.Short{int16(mobSpawner.delay)})

	return nil
}

Example #8

File: block_sign.go Project: compbrain/chunkymonkey

func (sign *signTileEntity) MarshalNbt(tag *nbt.Compound) (err error) {
	if err = sign.tileEntity.MarshalNbt(tag); err != nil {
		return
	}

	tag.Set("id", &nbt.String{"Sign"})
	tag.Set("Text1", &nbt.String{sign.text[0]})
	tag.Set("Text2", &nbt.String{sign.text[1]})
	tag.Set("Text3", &nbt.String{sign.text[2]})
	tag.Set("Text4", &nbt.String{sign.text[3]})

	return nil
}

Example #9

File: inv_dispenser.go Project: huwenshu/chunkymonkey

func (inv *DispenserInventory) MarshalNbt(tag *nbt.Compound) (err os.Error) {
	tag.Set("id", &nbt.String{"Trap"})
	return inv.Inventory.MarshalNbt(tag)
}

Example #10

File: inv_furnace.go Project: valtyr/chunkymonkey

func (inv *FurnaceInventory) MarshalNbt(tag *nbt.Compound) (err os.Error) {
	tag.Set("id", &nbt.String{"Furnace"})
	tag.Set("BurnTime", &nbt.Short{int16(inv.burnTime)})
	tag.Set("CookTime", &nbt.Short{int16(inv.cookTime)})
	return inv.Inventory.MarshalNbt(tag)
}

Example #11

File: slot.go Project: b1naryth1ef/chunkymonkey

func (s *Slot) MarshalNbt(tag nbt.Compound) (err error) {
	tag.Set("id", &nbt.Short{int16(s.ItemTypeId)})
	tag.Set("Count", &nbt.Byte{int8(s.Count)})
	tag.Set("Damage", &nbt.Short{int16(s.Data)})
	return nil
}

Example #12

File: mob.go Project: b1naryth1ef/chunkymonkey

func (mob *Mob) MarshalNbt(tag nbt.Compound) (err error) {
	mobTypeName, ok := MobNameByType[mob.mobType]
	if !ok {
		return errors.New("unknown mob type")
	}
	if err = mob.PointObject.MarshalNbt(tag); err != nil {
		return
	}
	tag.Set("id", &nbt.String{mobTypeName})
	tag.Set("Rotation", &nbt.List{nbt.TagFloat, []nbt.ITag{
		&nbt.Float{float32(mob.look.Yaw)},
		&nbt.Float{float32(mob.look.Pitch)},
	}})
	// TODO
	tag.Set("Air", &nbt.Short{0})
	tag.Set("AttackTime", &nbt.Short{0})
	tag.Set("DeathTime", &nbt.Short{0})
	tag.Set("FallDistance", &nbt.Float{0})
	tag.Set("Fire", &nbt.Short{0})
	tag.Set("Health", &nbt.Short{0})
	tag.Set("HurtTime", &nbt.Short{0})
	return nil
}

Example #13

File: player.go Project: compbrain/chunkymonkey

// MarshalNbt packs the player data into a nbt.Compound so it can be written to
// persistant storage.
func (player *Player) MarshalNbt(tag *nbt.Compound) (err error) {
	if err = player.inventory.MarshalNbt(tag); err != nil {
		return
	}

	tag.Set("OnGround", &nbt.Byte{player.onGround})
	tag.Set("Dimension", &nbt.Int{player.dimension})
	tag.Set("Sleeping", &nbt.Byte{player.sleeping})
	tag.Set("FallDistance", &nbt.Float{player.fallDistance})
	tag.Set("SleepTimer", &nbt.Short{player.sleepTimer})
	tag.Set("AttackTime", &nbt.Short{player.attackTime})
	tag.Set("DeathTime", &nbt.Short{player.deathTime})
	tag.Set("Motion", &nbt.List{nbt.TagDouble, []nbt.ITag{
		&nbt.Double{float64(player.motion.X)},
		&nbt.Double{float64(player.motion.Y)},
		&nbt.Double{float64(player.motion.Z)},
	}})
	tag.Set("HurtTime", &nbt.Short{player.hurtTime})
	tag.Set("Air", &nbt.Short{player.air})
	tag.Set("Rotation", &nbt.List{nbt.TagFloat, []nbt.ITag{
		&nbt.Float{float32(player.look.Yaw)},
		&nbt.Float{float32(player.look.Pitch)},
	}})
	tag.Set("Pos", &nbt.List{nbt.TagDouble, []nbt.ITag{
		&nbt.Double{float64(player.position.X)},
		&nbt.Double{float64(player.position.Y)},
		&nbt.Double{float64(player.position.Z)},
	}})
	tag.Set("Fire", &nbt.Short{player.fire})
	tag.Set("Health", &nbt.Short{int16(player.health)})

	return nil
}

Example #14

File: inv_chest.go Project: compbrain/chunkymonkey

func (inv *ChestInventory) MarshalNbt(tag *nbt.Compound) (err error) {
	tag.Set("id", &nbt.String{"Furnace"})
	return inv.Inventory.MarshalNbt(tag)
}

Example #15

File: inv_crafting.go Project: b1naryth1ef/chunkymonkey

func (inv *CraftingInventory) MarshalNbt(tag nbt.Compound) (err error) {
	tag.Set("id", &nbt.String{"Workbench"})
	return inv.Inventory.MarshalNbt(tag)
}