예제 #1
0
파일: slot.go 프로젝트: KellyLSB/minero-go
func (s *Slot) ReadFrom(r io.Reader) (n int64, err error) {
	var rw must.ReadWriter

	s.BlockId = rw.ReadInt16(r)
	if s.BlockId == -1 {
		return rw.Result()
	}

	s.Amount = byte(rw.ReadInt8(r))
	s.Damage = rw.ReadInt16(r)
	Length := rw.ReadInt16(r)

	if Length == -1 {
		return rw.Result()
	}

	var br bytes.Buffer

	// Copy gzip'd NBT Compound
	gs := rw.ReadByteArray(r, int(Length))
	bn := bytes.NewBuffer(gs)

	// Ungzip byte array
	gr, err := gzip.NewReader(bn)
	rw.Check(err)
	rw.Must(io.Copy(&br, gr))
	rw.Check(gr.Close())

	// Read NBT Compound
	s.Enchantments, err = nbt.Read(&br)
	rw.Check(err)

	return rw.Result()
}
예제 #2
0
func (m Metadata) ReadFrom(r io.Reader) (n int64, err error) {
	var rw must.ReadWriter

	var key byte
	for key != 0x7f {
		// Read type+key
		key = byte(rw.ReadInt8(r))
		if key == 0x7f {
			break
		}

		var (
			typ     byte  = key & 0xE0 >> 5
			index   byte  = key & 0x1F
			payload Entry = EntryFrom(typ)
		)

		// Read payload
		rw.Must(payload.ReadFrom(r))

		m.Entries[index] = payload
	}

	return rw.Result()
}
예제 #3
0
func (re *Region) ReadFrom(r io.Reader) (n int64, err error) {
	var rw must.ReadWriter

	// Copy everything to a buffer. Max size: 4MB + 8KB
	var all bytes.Buffer
	rw.Must(io.Copy(&all, r))

	// Read chunk positions.
	for i := 0; i < len(re.Pos); i++ {
		// Read 4KB offset from file start. Only first 3 bytes needed.
		re.Pos[i] = rw.ReadInt32(&all) >> 8

		// Fourth byte is a 4KB section counter which is ignored because we
		// already know the length of chunk data.
		//
		// More info here:
		// http://www.minecraftwiki.net/wiki/Region_file_format#Structure
		//
		// " The remainder of the file consists of data for up to 1024 chunks,
		// interspersed with an arbitrary amount of unused space. "
		//
		// TLDR: Just another idiotic/bad designed spec.
	}

	// Read chunk timestamps.
	//
	// Last modification time of a chunk. Unit: unknown, seconds?
	//
	// NOTE: Does something use this? MCEdit maybe?
	for i := 0; i < len(re.Mod); i++ {
		re.Mod[i] = rw.ReadInt32(&all)
	}

	// Read chunk data.
	for i := 0; i < len(re.Data); i++ {
		re.Data[i].Length = rw.ReadInt32(&all)
		re.Data[i].Compression = byte(rw.ReadInt8(&all))

		var buf bytes.Buffer
		io.CopyN(&buf, &all, length-1)

		switch scheme {
		case Gzip:
			panic("Alpha chunk format not implemented.")
		case Zlib:
			zr := zlib.NewReader(&all)
			io.Copy(&buf, zr)
		}

		re.Data[i].Chunk = buf.Bytes()
	}

	return rw.Result()
}