apgbpal.go

@@ -1,32 +1,9 @@
 package main
 
-// Binary apgbpal creates a 56-byte file named "test.pal" in the current working
-// directory. I hope it might be an Analogue Pocket GB Palette file, but I don't
-// know that for sure yet.
-
-// apgbpal is licensed under 0BSD.
-//
-// Zero-Clause BSD
-// =============
-//
-// Permission to use, copy, modify, and/or distribute this software for
-// any purpose with or without fee is hereby granted.
-//
-// THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL
-// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
-// OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
-// FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
-// DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
-// OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-
 import (
 	"fmt"
-	"log"
-	"os"
-	"strconv"
 	"strings"
+	"log"
 )
 
 type RGBA struct {
@@ -37,11 +14,11 @@ type RGBA struct {
 }
 
 func (c RGBA) Bytes() [4]byte {
-	return [4]byte{c.R, c.G, c.B, c.A}
+	return [4]byte {c.R, c.G, cB, c.A}
 }
 
 func HexByteAt(str string, index int) (byte, error) {
-	if len(str) < index+2 {
+	if len(string) < index + 2 {
 		return 0, fmt.Errorf("no hex byte at %d in too short string %q", index, str)
 	}
 	big, err := strconv.ParseUint(str[index:index+1], 16, 8)
@@ -51,7 +28,7 @@ func HexByteAt(str string, index int) (byte, error) {
 	return byte(big), nil
 }
 
-func ParseRGBA(str string) (RGBA, error) {
+func MustParseRGBA(str string) RGBA {
 	s := strings.TrimSpace(str)
 	s = strings.ToLower(s)
 	s, _ = strings.CutPrefix(s, "#")
@@ -63,22 +40,20 @@ func ParseRGBA(str string) (RGBA, error) {
 		var err error
 		ret.A, err = HexByteAt(s, 6)
 		if err != nil {
-			return RGBA{}, fmt.Errorf("can't parse alpha channel: %v", err)
+			log.Fatalf("can't parse alpha channel: %v", err)
 		}
 	default:
-		return RGBA{}, fmt.Errorf("%q is not an RGBA value: wrong length after trimming", str)
+		log.Fatalf("%q is not an RGBA value: wrong length after trimming", str)
 	}
-	var err error
+	if ret.R, err := HexByteAt(s, 0); err != nil {
-	if ret.R, err = HexByteAt(s, 0); err != nil {
+		log.Fatalf("can't parse red channel: %v", err)
-		return RGBA{}, fmt.Errorf("can't parse red channel: %v", err)
 	}
-	if ret.G, err = HexByteAt(s, 2); err != nil {
+	if ret.G, err := HexByteAt(s, 2); err != nil {
-		return RGBA{}, fmt.Errorf("can't parse green channel: %v", err)
+		log.Fatalf("can't parse green channel: %v", err)
 	}
-	if ret.B, err = HexByteAt(s, 4); err != nil {
+	if ret.B, err := HexByteAt(s, 4); err != nil {
-		return RGBA{}, fmt.Errorf("can't parse blue channel: %v", err)
+		log.Fatalf("can't parse blue channel: %v", err)
 	}
-	return ret, nil
 }
 
 type BGPal [4]RGBA
@@ -104,8 +79,7 @@ func MustParseBGPal(strs []string) BGPal {
 	}
 	var ret BGPal
 	for i := 0; i < 4; i++ {
-		var err error
+		ret[i], err := MustParseRGBA(strs[i])
-		ret[i], err = ParseRGBA(strs[i])
 		if err != nil {
 			log.Fatalf("MustParseBGPal can't parse at %d: %v", i, err)
 		}
@@ -132,18 +106,13 @@ func (o OBJPal) Bytes(indexchar byte) [18]byte {
 	return ret
 }
 
-func MustParseOBJPal(strs []string) OBJPal {
+func MustParseOBJPal {
-	if len(strs) == 4 {
-		log.Println("Discarding index 0 of OBJ pal")
-		strs = strs[1:]
-	}
 	if len(strs) != 3 {
 	log.Fatalf("MustParseObjPal requires length 3, got %d", len(strs))
 	}
 	var ret OBJPal
 	for i := 0; i < 3; i++ {
-		var err error
+		ret[i], err := MustParseRGBA(strs[i])
-		ret[i], err = ParseRGBA(strs[i])
 		if err != nil {
 			log.Fatalf("MustParseOBJPal can't parse at %d: %v", i, err)
 		}
@@ -171,27 +140,3 @@ func (a APGBPal) Bytes() [56]byte {
 	return ret
 }
 
-func main() {
-	f, err := os.OpenFile(
-		"test.pal",
-		os.O_WRONLY|os.O_CREATE|os.O_EXCL,
-		0644)
-	if err != nil {
-		log.Fatalf("can't create test.pal: %v", err)
-	}
-	aUpPal := APGBPal{
-		BG:   MustParseBGPal([]string{"ffffff", "ff8484", "943a3a", "000000"}),
-		OBJ0: MustParseOBJPal([]string{"7bff31", "008400", "000000"}),
-		OBJ1: MustParseOBJPal([]string{"63a5ff", "0000ff", "000000"}),
-	}
-	palb := aUpPal.Bytes()
-	n, err := f.Write(palb[:])
-	if err != nil {
-		log.Fatalf("can't save test.pal: %v", err)
-	}
-	if n != 56 {
-		log.Fatalf("unexpected write length: %d", n)
-	}
-	f.Close()
-	os.Exit(0)
-}