GopherMc

✨ Features

📦 Installation

go get github.com/IzomSoftware/GopherMc

🚀 Usage Examples

1. Get Server Status

package main
import (
	"context"
	"fmt"
	"github.com/IzomSoftware/GopherMc"
	"log"
	"time"
)
func main() {
	host := "127.0.0.1"
	port := uint16(25565)
	
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	
	client, err := GopherMc.NewClient(
		GopherMc.WithAddr(fmt.Sprintf("%s:%d", host, port)),
	)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	defer client.Close()
	
	statusJSON, latency, err := client.GetStatus(ctx)
	if err != nil {
		log.Fatalf("Failed to get server status: %v", err)
	}
	
	fmt.Printf("Server Status:\n%s\n", statusJSON)
	fmt.Printf("Latency: %v\n", latency)
}

2. Send a Chat Message

package main
import (
	"context"
	"fmt"
	"github.com/IzomSoftware/GopherMc"
	"github.com/IzomSoftware/GopherMc/protocol"
	"log"
	"time"
)
func main() {
	host := "127.0.0.1"
	port := uint16(25565)
	username := "GopherBot"
	message := "Hello from GopherMc!"
	
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	
	client, err := GopherMc.NewClient(
		GopherMc.WithAddr(fmt.Sprintf("%s:%d", host, port)),
		GopherMc.WithUsername(username),
	)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	
	if err := client.Join(ctx); err != nil {
		log.Fatalf("Failed to join server: %v", err)
	}
	defer client.Destroy()
	
	// Wait a moment for the server to process the login
	time.Sleep(time.Second * 2)
	
	if err := client.Chat(message); err != nil {
		log.Fatalf("Sending chat failed: %v", err)
	}
	
	log.Println("Successfully sent chat message!")
}

3. Advanced Client with Event Handling

package main
import (
	"context"
	"fmt"
	"github.com/IzomSoftware/GopherMc"
	"log"
)
func main() {
	host := "127.0.0.1"
	port := uint16(25565)
	username := "GopherMC"
	
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	
	client, err := GopherMc.NewClient(
		GopherMc.WithAddr(fmt.Sprintf("%s:%d", host, port)),
		GopherMc.WithUsername(username),
	)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	
	// Login and start listening for events
	events, err := client.JoinAndListen(ctx, 100)
	if err != nil {
		log.Fatalf("LoginAndListen failed: %v", err)
	}
	defer client.Destroy()
	
	log.Println("Login successful, listening for events...")
	
	// Event loop
	for {
		select {
		case event := <-events:
			if event == nil {
				log.Println("Event channel closed. Exiting.")
				return
			}
			
			// Handle different event types
			switch e := event.(type) {
			case GopherMc.ReadyEvent:
				log.Printf("Client is ready! Logged in as %s\n", e.Username)
			
			case GopherMc.ChatMessageEvent:
				fmt.Printf("[Chat] <%s>: %s\n", e.Sender, e.Message)
			case GopherMc.KeepAliveEvent:
				log.Printf("Received KeepAlive (ID: %d). Client is responding automatically.\n", e.ID)
			case GopherMc.DisconnectEvent:
				log.Printf("Disconnected by server: %s\n", e.Reason)
				return
			default:
				log.Printf("Received unhandled event: %T\n", e)
			}
		case <-ctx.Done():
			log.Println("Program context finished.")
			return
		}
	}
}

🔬 Running Tests

go test ./... -v

🤝 Contributing

📜 License

©️ Credits: