Implement Font type for rbxl and rbxlx.

Author: Anaminus

rbxl/arrays.go

@@ -322,6 +322,8 @@ func newArray(t typeID, n int) array {
 		}
 	case typeUniqueId:
 		return make(arrayUniqueId, n)
+	case typeFont:
+		return make(arrayFont, n)
 	}
 	return nil
 }
@@ -1528,3 +1530,39 @@ func (a arrayUniqueId) Bytes(b []byte) []byte {
 func (a arrayUniqueId) Interleaved() {}
 
 ////////////////////////////////////////////////////////////////////////////////
+
+type arrayFont []valueFont
+
+func (arrayFont) Type() typeID {
+	return typeFont
+}
+
+func (a arrayFont) Len() int {
+	return len(a)
+}
+
+func (a arrayFont) Get(i int) value {
+	v := a[i]
+	return &v
+}
+
+func (a arrayFont) Set(i int, v value) {
+	a[i] = *v.(*valueFont)
+}
+
+func (a arrayFont) BytesLen() int {
+	var n int
+	for _, v := range a {
+		n += v.BytesLen()
+	}
+	return n
+}
+
+func (a arrayFont) Bytes(b []byte) []byte {
+	for _, v := range a {
+		b = v.Bytes(b)
+	}
+	return b
+}
+
+////////////////////////////////////////////////////////////////////////////////

rbxl/codec.go

@@ -403,6 +403,14 @@ func decodeValue(val value) rbxfile.Value {
 			Index:  value.Index,
 		}
 
+	case *valueFont:
+		return rbxfile.ValueFont{
+			Family:       rbxfile.ValueContent(value.Family),
+			Weight:       rbxfile.FontWeight(value.Weight),
+			Style:        rbxfile.FontStyle(value.Style),
+			CachedFaceId: rbxfile.ValueContent(value.CachedFaceId),
+		}
+
 	default:
 		return nil
 	}
@@ -977,6 +985,14 @@ func encodeValue(val rbxfile.Value) value {
 			Index:  value.Index,
 		}
 
+	case rbxfile.ValueFont:
+		return &valueFont{
+			Family:       valueString(value.Family),
+			Weight:       uint16(value.Weight),
+			Style:        uint8(value.Style),
+			CachedFaceId: valueString(value.CachedFaceId),
+		}
+
 	default:
 		return nil
 	}

rbxl/values.go

@@ -34,6 +34,9 @@ const (
 	// Variable size, where the type is optional.
 	zOpt = -3
 
+	// Variable size, custom implementation.
+	zOther = -4
+
 	// Number of bytes used to contain length of a zArray type.
 	zArrayLen = 4
 
@@ -90,11 +93,12 @@ const (
 	typeSignedString       typeID = 0x1D //TODO
 	typeOptional           typeID = 0x1E
 	typeUniqueId           typeID = 0x1F
+	typeFont               typeID = 0x20
 )
 
 // Valid returns whether the type has a valid value.
 func (t typeID) Valid() bool {
-	return typeString <= t && t <= typeUniqueId && t != typeSignedString
+	return typeString <= t && t <= typeFont && t != typeSignedString
 }
 
 // Size returns the number of bytes required to hold a value of the type.
@@ -164,6 +168,8 @@ func (t typeID) Size() int {
 		return zOptional
 	case typeUniqueId:
 		return zUniqueId
+	case typeFont:
+		return zFont
 	default:
 		return zInvalid
 	}
@@ -273,6 +279,8 @@ func (t typeID) String() string {
 		return "Optional"
 	case typeUniqueId:
 		return "UniqueId"
+	case typeFont:
+		return "Font"
 	default:
 		return "Invalid"
 	}
@@ -341,6 +349,8 @@ func (t typeID) ValueType() rbxfile.Type {
 		return rbxfile.TypeOptional
 	case typeUniqueId:
 		return rbxfile.TypeUniqueId
+	case typeFont:
+		return rbxfile.TypeFont
 	default:
 		return rbxfile.TypeInvalid
 	}
@@ -413,6 +423,8 @@ func fromValueType(t rbxfile.Type) typeID {
 		return typeOptional
 	case rbxfile.TypeUniqueId:
 		return typeUniqueId
+	case rbxfile.TypeFont:
+		return typeFont
 	default:
 		return typeInvalid
 	}
@@ -501,6 +513,8 @@ func newValue(typ typeID) value {
 		return nil
 	case typeUniqueId:
 		return new(valueUniqueId)
+	case typeFont:
+		return new(valueFont)
 	}
 	return nil
 }
@@ -2228,3 +2242,95 @@ func (v valueUniqueId) Dump(w *bufio.Writer, indent int) {
 	dumpNewline(w, indent)
 	w.WriteByte('}')
 }
+
+////////////////////////////////////////////////////////////////
+
+const zFont = zOther // String + u16 + u8 + String
+
+type valueFont struct {
+	Family       valueString
+	Weight       uint16
+	Style        uint8
+	CachedFaceId valueString
+}
+
+func (valueFont) Type() typeID {
+	return typeFont
+}
+
+func (v valueFont) BytesLen() int {
+	return v.Family.BytesLen() + zu16 + zu8 + v.CachedFaceId.BytesLen()
+}
+
+func (v valueFont) Bytes(b []byte) []byte {
+	b = v.Family.Bytes(b)
+	b = appendUint16(b, le, v.Weight)
+	b = append(b, v.Style)
+	b = v.CachedFaceId.Bytes(b)
+	return b
+}
+
+func (v *valueFont) FromBytes(b []byte) (n int, err error) {
+	l := len(b)
+
+	nn, err := v.Family.FromBytes(b)
+	n += nn
+	if err != nil {
+		return n, err
+	}
+	b = b[nn:]
+
+	nn = zu16
+	n += nn
+	if len(b) < nn {
+		return n, buflenError{exp: uint64(n), got: l}
+	}
+	v.Weight = readUint16(&b, le)
+
+	nn = zu8
+	n += nn
+	if len(b) < nn {
+		return n, buflenError{exp: uint64(n), got: l}
+	}
+	v.Style = readUint8(&b)
+
+	nn, err = v.CachedFaceId.FromBytes(b)
+	n += nn
+	if err != nil {
+		return n, err
+	}
+	b = b[nn:]
+
+	return n, nil
+}
+
+func (v valueFont) Dump(w *bufio.Writer, indent int) {
+	w.WriteByte('{')
+
+	dumpNewline(w, indent+1)
+	w.WriteString("Family: ")
+	v.Family.Dump(w, indent+1)
+
+	dumpNewline(w, indent+1)
+	w.WriteString("Weight: ")
+	w.WriteString(rbxfile.FontWeight(v.Weight).String())
+	w.WriteString(" (")
+	w.Write(strconv.AppendInt(nil, int64(v.Weight), 10))
+	w.WriteString(")")
+
+	dumpNewline(w, indent+1)
+	w.WriteString("Style: ")
+	w.WriteString(rbxfile.FontStyle(v.Style).String())
+	w.WriteString(" (")
+	w.Write(strconv.AppendInt(nil, int64(v.Style), 10))
+	w.WriteString(")")
+
+	dumpNewline(w, indent+1)
+	w.WriteString("CachedFaceId: ")
+	v.CachedFaceId.Dump(w, indent+1)
+
+	dumpNewline(w, indent)
+	w.WriteByte('}')
+}
+
+////////////////////////////////////////////////////////////////

rbxlx/codec.go

@@ -314,6 +314,8 @@ func (robloxCodec) GetCanonTag(valueType rbxfile.Type, optional bool) (canonTag
 		canonTag = "SharedString"
 	case rbxfile.TypeUniqueId:
 		canonTag = "UniqueId"
+	case rbxfile.TypeFont:
+		canonTag = "Font"
 	}
 	if optional {
 		canonTag = "Optional" + canonTag
@@ -391,6 +393,8 @@ func (robloxCodec) GetCanonType(valueType string) (canonType rbxfile.Type, optio
 		canonType = rbxfile.TypeSharedString
 	case "uniqueid":
 		canonType = rbxfile.TypeUniqueId
+	case "font":
+		canonType = rbxfile.TypeFont
 	}
 	return canonType, optional
 }
@@ -937,6 +941,39 @@ func (dec *rdecoder) getValue(tag *documentTag, valueType rbxfile.Type) (value r
 		v.Time = binary.BigEndian.Uint32(b[8:12])
 		v.Index = binary.BigEndian.Uint32(b[12:16])
 		return v, true
+
+	case rbxfile.TypeFont:
+		var v rbxfile.ValueFont
+		var family *documentTag
+		var cachedFaceId *documentTag
+		ok := components{
+			"Family": &family,
+			"Weight": &v.Weight,
+			"Style":  &v.Style,
+		}.getFrom(tag)
+		if !ok {
+			goto fontFailed
+		}
+		{
+			vFamily, ok := dec.getValue(family, rbxfile.TypeContent)
+			if !ok {
+				goto fontFailed
+			}
+			v.Family = vFamily.(rbxfile.ValueContent)
+		}
+		if ok := (components{"CachedFaceId": &cachedFaceId}.getFrom(tag)); ok {
+			vCachedFaceId, ok := dec.getValue(cachedFaceId, rbxfile.TypeContent)
+			if !ok {
+				goto fontFailed
+			}
+			v.CachedFaceId = vCachedFaceId.(rbxfile.ValueContent)
+		}
+		return v, true
+	fontFailed:
+		if dec.codec.DiscardInvalidProperties {
+			return nil, false
+		}
+		return rbxfile.ValueFont{}, true
 	}
 	return nil, false
 }
@@ -1009,6 +1046,22 @@ func (c components) getFrom(tag *documentTag) (ok bool) {
 				if n, err := strconv.ParseFloat(getContent(subtag), 32); err == nil {
 					*v = float32(n)
 				}
+			case *rbxfile.FontStyle:
+				f, ok := rbxfile.FontStyleFromString(getContent(subtag))
+				if !ok {
+					return false
+				}
+				*v = f
+			case *rbxfile.FontWeight:
+				// Parse as uint16.
+				n, err := strconv.ParseInt(getContent(subtag), 10, 16)
+				*v = rbxfile.FontWeight(n)
+				if err != nil {
+					if errors.Is(err, strconv.ErrRange) {
+						return true
+					}
+					return false
+				}
 			case **documentTag:
 				*v = subtag
 			}
@@ -1596,6 +1649,24 @@ func (enc *rencoder) encodeProperty(value rbxfile.Value) *documentTag {
 			StartName: "UniqueId",
 			Text:      hex.EncodeToString(b[:]),
 		}
+
+	case rbxfile.ValueFont:
+		family := enc.encodeProperty(value.Family)
+		family.StartName = "Family"
+		parent := &documentTag{
+			StartName: "Font",
+			Tags: []*documentTag{
+				family,
+				{StartName: "Weight", NoIndent: true, Text: strconv.FormatInt(int64(value.Weight), 10)},
+				{StartName: "Style", NoIndent: true, Text: value.Style.String()},
+			},
+		}
+		if len(value.CachedFaceId) > 0 {
+			cachedFaceId := enc.encodeProperty(value.CachedFaceId)
+			cachedFaceId.StartName = "CachedFaceId"
+			parent.Tags = append(parent.Tags, cachedFaceId)
+		}
+		return parent
 	}
 
 	return nil