Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Untitled conversation

  1. User

    [18:09:01] [Render thread/INFO]: Environment: authHost='https://authserver.mojang.com', accountsHost='https://api.mojang.com', sessionHost='https://sessionserver.mojang.com', servicesHost='https://api.minecraftservices.com', name='PROD' [18:09:02] [Render thread/INFO]: Setting user: MAKAR566 [18:09:02] [Render thread/INFO]: Backend library: LWJGL version 3.2.1 build 12 [18:09:02] [Render thread/INFO]: [STDERR]: [LWJGL] [ERROR] Incompatible Java and native library versions detected. Possible reasons: a) -Djava.library.path is set to a folder containing shared libraries of an older LWJGL version. b) The classpath contains jar files of an older LWJGL version. Possible solutions: a) Make sure to not set -Djava.library.path (it is not needed for developing with LWJGL 3) or make sure the folder it points to contains the shared libraries of the correct LWJGL version. b) Check the classpath and make sure to only have jar files of the same LWJGL version in it. [18:09:02] [Render thread/INFO]: [STDERR]: [LWJGL] [ThreadLocalUtil] Unsupported JNI version detected, this may result in a crash. Please inform LWJGL developers.

    A fatal error has been detected by the Java Runtime Environment:

    EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00007ff97510cb76, pid=30944, tid=11256

    JRE version: Java(TM) SE Runtime Environment (21.0.4+8) (build 21.0.4+8-LTS-274)

    Java VM: Java HotSpot(TM) 64-Bit Server VM (21.0.4+8-LTS-274, mixed mode, sharing, tiered, compressed oops, compressed class ptrs, g1 gc, windows-amd64)

    Problematic frame:

    V [jvm.dll+0x43cb76]

    No core dump will be written. Minidumps are not enabled by default on client versions of Windows

    An error report file with more information is saved as:

    D:\JBProjects\GOLAND\MineLauncherTest.legit\hs_err_pid30944.log

    If you would like to submit a bug report, please visit:

    https://bugreport.java.com/bugreport/crash.jsp

    panic: ошибка при запуске Minecraft: ошибка при запуске Minecraft: exit status 1

    goroutine 1 [running]: main.main() D:/JBProjects/GOLAND/MineLauncherTest/main.go:31 +0x259

    package launcher

    import ( "archive/zip" "crypto/rand" "crypto/sha1" "encoding/hex" "encoding/json" "fmt" "io" "net/http" "os" "os/exec" "path/filepath" "runtime" "strings" "sync" "time" )

    const versionManifestURL = "https://launchermeta.mojang.com/mc/game/version_manifest_v2.json"

    type VersionManifest struct { Latest struct { Release string json:"release" Snapshot string json:"snapshot" } json:"latest" Versions []struct { ID string json:"id" Type string json:"type" URL string json:"url,omitempty" Time string json:"time,omitempty" ReleaseTime string json:"releaseTime,omitempty" } json:"versions" }

    type VersionData map[string]interface{}

    type Launcher struct { minelauncherPath string versionManifest *VersionManifest }

    func NewLauncher() *Launcher { return &Launcher{ minelauncherPath: ".minecraft", // Задаем путь по умолчанию } }

    func (l *Launcher) SetMinecraftPath(path string) { l.minelauncherPath = path }

    func (l *Launcher) GetMinecraftPath() string { return l.minelauncherPath }

    func (l *Launcher) loadCustomVersions() ([]struct { ID string json:"id" Type string json:"type" URL string json:"url,omitempty" Time string json:"time,omitempty" ReleaseTime string json:"releaseTime,omitempty" }, error) { var customVersions []struct { ID string json:"id" Type string json:"type" URL string json:"url,omitempty" Time string json:"time,omitempty" ReleaseTime string json:"releaseTime,omitempty" }

    versionsDir := filepath.Join(l.minelauncherPath, "versions")
    entries, err := os.ReadDir(versionsDir)
    if err != nil {
    	return nil, fmt.Errorf("ошибка при чтении директории версий: %v", err)
    }
    
    for _, entry := range entries {
    	if entry.IsDir() {
    		versionID := entry.Name()
    		versionJsonPath := filepath.Join(versionsDir, versionID, versionID+".json")
    		if _, err := os.Stat(versionJsonPath); err == nil {
    			data, err := os.ReadFile(versionJsonPath)
    			if err != nil {
    				fmt.Printf("Предупреждение: не удалось прочитать файл версии %s: %v\n", versionJsonPath, err)
    				continue
    			}
    			var versionData map[string]interface{}
    			err = json.Unmarshal(data, &versionData)
    			if err != nil {
    				fmt.Printf("Предупреждение: ошибка при разборе данных версии %s: %v\n", versionJsonPath, err)
    				continue
    			}
    
    			versionType, ok := versionData["type"].(string)
    			if !ok {
    				versionType = "custom" // Default type
    			}
    
    			// Append custom version
    			customVersions = append(customVersions, struct {
    				ID          string `json:"id"`
    				Type        string `json:"type"`
    				URL         string `json:"url,omitempty"`
    				Time        string `json:"time,omitempty"`
    				ReleaseTime string `json:"releaseTime,omitempty"`
    			}{
    				ID:   versionID,
    				Type: versionType,
    			})
    		}
    	}
    }
    
    return customVersions, nil
    

    }

    func (l *Launcher) getVersionManifest() (*VersionManifest, error) { fmt.Println("Получение манифеста версий...")

    // Fetch the official version manifest
    resp, err := http.Get(versionManifestURL)
    if err != nil {
    	return nil, fmt.Errorf("не удалось получить манифест версий: %v", err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
    	return nil, fmt.Errorf("не удалось получить манифест версий, статус код: %d", resp.StatusCode)
    }
    
    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
    	return nil, fmt.Errorf("не удалось прочитать тело ответа манифеста версий: %v", err)
    }
    
    var manifest VersionManifest
    err = json.Unmarshal(bodyBytes, &manifest)
    if err != nil {
    	return nil, fmt.Errorf("ошибка при разборе манифеста версий: %v", err)
    }
    
    // Scan for custom versions in the 'versions' directory
    customVersions, err := l.loadCustomVersions()
    if err != nil {
    	fmt.Printf("Предупреждение: не удалось загрузить пользовательские версии: %v\n", err)
    } else {
    	manifest.Versions = append(manifest.Versions, customVersions...)
    }
    
    return &manifest, nil
    

    }

    func (l *Launcher) GetMinecraftVersions() ([]string, error) { if l.versionManifest == nil { manifest, err := l.getVersionManifest() if err != nil { return nil, err } l.versionManifest = manifest }

    versionsMap := make(map[string]string)
    for _, v := range l.versionManifest.Versions {
    	if v.Type == "custom" {
    		versionsMap[v.ID] = fmt.Sprintf("%s (custom)", v.ID)
    	} else {
    		versionsMap[v.ID] = fmt.Sprintf("%s (%s)", v.ID, v.Type)
    	}
    }
    
    // Собираем версии в слайс
    versions := []string{}
    for _, v := range versionsMap {
    	versions = append(versions, v)
    }
    return versions, nil
    

    }

    func (l *Launcher) getVersionDetails(versionID string) (VersionData, error) { fmt.Printf("Получение данных для версии: %s\n", versionID)

    // Проверяем локальный JSON-файл версии
    versionJsonPath := filepath.Join(l.minelauncherPath, "versions", versionID, versionID+".json")
    if _, err := os.Stat(versionJsonPath); err == nil {
    	// Локальный JSON существует, загружаем его
    	data, err := os.ReadFile(versionJsonPath)
    	if err != nil {
    		return nil, fmt.Errorf("не удалось прочитать локальный файл версии %s: %v", versionJsonPath, err)
    	}
    	var versionData VersionData
    	err = json.Unmarshal(data, &versionData)
    	if err != nil {
    		return nil, fmt.Errorf("ошибка при разборе локальных данных версии %s: %v", versionJsonPath, err)
    	}
    	return versionData, nil
    }
    
    // Иначе получаем данные версии из официального манифеста
    var versionURL string
    for _, version := range l.versionManifest.Versions {
    	if version.ID == versionID {
    		versionURL = version.URL
    		break
    	}
    }
    if versionURL == "" {
    	return nil, fmt.Errorf("версия %s не найдена в манифесте", versionID)
    }
    
    resp, err := http.Get(versionURL)
    if err != nil {
    	return nil, fmt.Errorf("не удалось получить данные версии: %v", err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
    	return nil, fmt.Errorf("не удалось получить данные версии, статус код: %d", resp.StatusCode)
    }
    
    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
    	return nil, fmt.Errorf("не удалось прочитать тело ответа версии: %v", err)
    }
    
    var versionData VersionData
    err = json.Unmarshal(bodyBytes, &versionData)
    if err != nil {
    	return nil, fmt.Errorf("ошибка при разборе данных версии: %v", err)
    }
    return versionData, nil
    

    }

    func (l *Launcher) mergeVersionData(versionData VersionData) (VersionData, error) { if parentID, ok := versionData["inheritsFrom"].(string); ok { parentData, err := l.getVersionDetails(parentID) if err != nil { return nil, fmt.Errorf("ошибка при получении родительской версии %s: %v", parentID, err) } // Рекурсивно объединяем данные родительской версии parentData, err = l.mergeVersionData(parentData) if err != nil { return nil, err } // Объединяем данные parentData в versionData mergedData := l.deepMergeVersionData(parentData, versionData) return mergedData, nil } return versionData, nil }

    func (l *Launcher) deepMergeVersionData(parent, child VersionData) VersionData { merged := make(VersionData) // Копируем данные родительской версии for k, v := range parent { merged[k] = v } // Переопределяем данными дочерней версии for k, v := range child { if k == "libraries" { // Объединяем массивы библиотек parentLibs, _ := parent["libraries"].([]interface{}) childLibs, _ := v.([]interface{}) mergedLibs := append(parentLibs, childLibs...) merged["libraries"] = mergedLibs } else if k == "arguments" { // Объединяем аргументы parentArgs, _ := parent["arguments"].(map[string]interface{}) childArgs, _ := v.(map[string]interface{}) mergedArgs := make(map[string]interface{}) for ak, av := range parentArgs { if childArgValue, hasChildArg := childArgs[ak]; hasChildArg { if isNonEmpty(childArgValue) { // Если дочерний аргумент не пустой, используем его mergedArgs[ak] = childArgValue } else { // Если дочерний аргумент пустой, сохраняем родительский mergedArgs[ak] = av } } else { // Если в дочерней версии нет этого аргумента, сохраняем родительский mergedArgs[ak] = av } } // Добавляем новые аргументы из дочерней версии, которых нет в родительской for ak, av := range childArgs { if _, exists := parentArgs[ak]; !exists { mergedArgs[ak] = av } } merged["arguments"] = mergedArgs } else if k == "logging" { // Переопределяем logging merged["logging"] = v } else { merged[k] = v } } return merged }

    func isNonEmpty(value interface{}) bool { if value == nil { return false } switch v := value.(type) { case []interface{}: return len(v) > 0 case map[string]interface{}: return len(v) > 0 default: return true } }

    func (l *Launcher) downloadFile(url, filepath string) error { fmt.Printf("Скачивание файла: %s\n", url) client := http.Client{ Timeout: 30 * time.Second, }

    resp, err := client.Get(url)
    if err != nil {
    	return fmt.Errorf("ошибка при выполнении GET-запроса: %v", err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
    	return fmt.Errorf("не удалось скачать файл: %s, статус код: %d", url, resp.StatusCode)
    }
    
    out, err := os.Create(filepath)
    if err != nil {
    	return fmt.Errorf("не удалось создать файл %s: %v", filepath, err)
    }
    defer out.Close()
    
    _, err = io.Copy(out, resp.Body)
    if err != nil {
    	return fmt.Errorf("ошибка при записи файла %s: %v", filepath, err)
    }
    
    fmt.Printf("Файл скачан и сохранён: %s\n", filepath)
    return nil
    

    }

    func (l *Launcher) downloadFileWithRetry(url, filepath string, retries int) error { for i := 0; i <= retries; i++ { err := l.downloadFile(url, filepath) if err == nil { return nil } fmt.Printf("Попытка %d скачать файл %s не удалась, ошибка: %v\n", i+1, url, err) time.Sleep(2 * time.Second) } return fmt.Errorf("не удалось скачать файл после %d попыток: %s", retries+1, url) }

    func (l *Launcher) verifyFileChecksum(filePath, expectedHash string) bool { file, err := os.Open(filePath) if err != nil { fmt.Printf("Не удалось открыть файл для проверки хэша: %s, ошибка: %v\n", filePath, err) return false } defer file.Close()

    hash := sha1.New()
    if _, err := io.Copy(hash, file); err != nil {
    	fmt.Printf("Не удалось вычислить хэш для файла: %s, ошибка: %v\n", filePath, err)
    	return false
    }
    calculatedHash := hex.EncodeToString(hash.Sum(nil))
    if expectedHash != calculatedHash {
    	fmt.Printf("Хэш не совпадает для файла: %s (ожидалось: %s, получено: %s)\n", filePath, expectedHash, calculatedHash)
    	return false
    }
    return true
    

    }

    func (l *Launcher) shouldIncludeLibrary(libInfo map[string]interface{}) bool { allowed := true if rules, ok := libInfo["rules"].([]interface{}); ok { for _, ruleInterface := range rules { rule, ok := ruleInterface.(map[string]interface{}) if !ok { continue } action, ok := rule["action"].(string) if !ok { continue }

    		applies := true
    
    		if osDict, ok := rule["os"].(map[string]interface{}); ok {
    			osName := runtime.GOOS
    			if osName == "darwin" {
    				osName = "osx"
    			}
    			if name, ok := osDict["name"].(string); ok && name != osName {
    				applies = false
    			}
    		}
    
    		if applies {
    			if action == "allow" {
    				allowed = true
    			} else if action == "disallow" {
    				allowed = false
    			}
    		}
    	}
    }
    return allowed
    

    }

    func (l *Launcher) getNatives(libInfo map[string]interface{}) string { archType := "64" if runtime.GOARCH == "386" || runtime.GOARCH == "arm" { archType = "32" }

    natives, ok := libInfo["natives"].(map[string]interface{})
    if !ok {
    	return ""
    }
    
    var classifierName string
    switch runtime.GOOS {
    case "windows":
    	if val, exists := natives["windows"].(string); exists {
    		classifierName = strings.ReplaceAll(val, "${arch}", archType)
    	}
    case "darwin":
    	if val, exists := natives["osx"].(string); exists {
    		classifierName = strings.ReplaceAll(val, "${arch}", archType)
    	}
    case "linux":
    	if val, exists := natives["linux"].(string); exists {
    		classifierName = strings.ReplaceAll(val, "${arch}", archType)
    	}
    default:
    	return ""
    }
    
    return classifierName
    

    }

    func (l *Launcher) unzip(src, dest string) error { fmt.Printf("Распаковка архива: %s в %s\n", src, dest) r, err := zip.OpenReader(src) if err != nil { return fmt.Errorf("не удалось открыть ZIP-архив %s: %v", src, err) } defer r.Close()

    for _, f := range r.File {
    	if strings.HasPrefix(f.Name, "META-INF") {
    		continue
    	}
    
    	fpath := filepath.Join(dest, f.Name)
    
    	// Проверка на безопасность пути
    	if !strings.HasPrefix(fpath, filepath.Clean(dest)+string(os.PathSeparator)) {
    		return fmt.Errorf("недопустимый путь в архиве: %s", fpath)
    	}
    
    	if f.FileInfo().IsDir() {
    		err := os.MkdirAll(fpath, os.ModePerm)
    		if err != nil {
    			return fmt.Errorf("не удалось создать директорию %s: %v", fpath, err)
    		}
    		continue
    	}
    
    	if err := os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
    		return fmt.Errorf("не удалось создать директорию %s: %v", filepath.Dir(fpath), err)
    	}
    
    	outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
    	if err != nil {
    		return fmt.Errorf("не удалось открыть файл для записи %s: %v", fpath, err)
    	}
    
    	rc, err := f.Open()
    	if err != nil {
    		outFile.Close()
    		return fmt.Errorf("не удалось открыть файл внутри архива %s: %v", f.Name, err)
    	}
    
    	_, err = io.Copy(outFile, rc)
    	outFile.Close()
    	rc.Close()
    
    	if err != nil {
    		return fmt.Errorf("ошибка при копировании файла %s: %v", fpath, err)
    	}
    }
    return nil
    

    }

    func (l *Launcher) verifyMainClass(clientJarPath string) bool { r, err := zip.OpenReader(clientJarPath) if err != nil { fmt.Printf("Не удалось открыть client.jar для проверки main class: %v\n", err) return false } defer r.Close()

    target := "net/minecraft/client/main/Main.class"
    for _, f := range r.File {
    	if f.Name == target {
    		return true
    	}
    }
    fmt.Println("Main class не найден в client.jar")
    return false
    

    }

    func (l *Launcher) downloadClientJar(versionData VersionData, versionID string) error { fmt.Println("Скачивание клиентского JAR-файла...")

    dirPath := filepath.Join(l.minelauncherPath, "versions", versionID)
    os.MkdirAll(dirPath, os.ModePerm)
    filePath := filepath.Join(dirPath, versionID+".jar")
    
    // Проверяем, существует ли файл client.jar
    if _, err := os.Stat(filePath); err == nil {
    	fmt.Println("Клиентский JAR-файл уже существует, пропускаем скачивание.")
    	return nil
    }
    
    // Проверяем, есть ли указание на загрузку клиентского JAR-файла
    downloads, ok := versionData["downloads"].(map[string]interface{})
    if ok {
    	client, ok := downloads["client"].(map[string]interface{})
    	if ok {
    		url, ok := client["url"].(string)
    		if !ok {
    			return fmt.Errorf("не удалось получить URL клиента")
    		}
    		expectedHash, _ := client["sha1"].(string)
    
    		absFilePath, err := filepath.Abs(filePath)
    		if err != nil {
    			return fmt.Errorf("не удалось получить абсолютный путь к файлу %s: %v", filePath, err)
    		}
    
    		err = l.downloadFileWithRetry(url, absFilePath, 4)
    		if err != nil {
    			return fmt.Errorf("ошибка при скачивании клиентского JAR-файла: %v", err)
    		}
    
    		if expectedHash != "" && !l.verifyFileChecksum(absFilePath, expectedHash) {
    			return fmt.Errorf("хэш клиентского JAR-файла не совпадает после загрузки")
    		}
    
    		if !l.verifyMainClass(absFilePath) {
    			return fmt.Errorf("файл client.jar не содержит необходимого основного класса")
    		}
    
    		return nil
    	}
    }
    
    // Если не удалось найти информацию о загрузке, проверяем наличие "inheritsFrom"
    if parentID, ok := versionData["inheritsFrom"].(string); ok {
    	// Пытаемся использовать client.jar родительской версии
    	parentClientJar := filepath.Join(l.minelauncherPath, "versions", parentID, parentID+".jar")
    	if _, err := os.Stat(parentClientJar); err != nil {
    		// Если файл не существует, скачиваем родительскую версию
    		parentData, err := l.getVersionDetails(parentID)
    		if err != nil {
    			return fmt.Errorf("не удалось получить данные родительской версии %s: %v", parentID, err)
    		}
    		err = l.downloadClientJar(parentData, parentID)
    		if err != nil {
    			return err
    		}
    	}
    	// Копируем client.jar из родительской версии
    	err := copyFile(parentClientJar, filePath)
    	if err != nil {
    		return fmt.Errorf("не удалось скопировать client.jar из родительской версии: %v", err)
    	}
    	return nil
    }
    
    return fmt.Errorf("не удалось скачать или найти client.jar для версии %s", versionID)
    

    }

    func copyFile(src, dst string) error { input, err := os.Open(src) if err != nil { return fmt.Errorf("не удалось открыть файл %s для копирования: %v", src, err) } defer input.Close()

    output, err := os.Create(dst)
    if err != nil {
    	return fmt.Errorf("не удалось создать файл %s для копирования: %v", dst, err)
    }
    defer output.Close()
    
    _, err = io.Copy(output, input)
    if err != nil {
    	return fmt.Errorf("ошибка при копировании файла %s в %s: %v", src, dst, err)
    }
    
    return nil
    

    }

    func (l *Launcher) downloadLibraries(versionData VersionData) error { fmt.Println("Скачивание библиотек...") libraries, ok := versionData["libraries"].([]interface{}) if !ok { return fmt.Errorf("не удалось получить библиотеки из данных версии") } var wg sync.WaitGroup semaphore := make(chan struct{}, 10)

    for _, lib := range libraries {
    	libInfo, ok := lib.(map[string]interface{})
    	if !ok {
    		continue
    	}
    
    	if !l.shouldIncludeLibrary(libInfo) {
    		continue
    	}
    
    	var downloadInfo map[string]interface{}
    	downloads, hasDownloads := libInfo["downloads"].(map[string]interface{})
    	if hasDownloads {
    		artifact, hasArtifact := downloads["artifact"].(map[string]interface{})
    		if hasArtifact {
    			downloadInfo = artifact
    		}
    	} else {
    		// Обработка старого формата
    		name, ok := libInfo["name"].(string)
    		if !ok {
    			continue
    		}
    		var url string
    		if customURL, ok := libInfo["url"].(string); ok {
    			url = customURL
    		} else {
    			url = "https://libraries.minecraft.net/"
    		}
    
    		path := l.mavenArtifactPath(name)
    		fullURL := url + path
    
    		downloadInfo = map[string]interface{}{
    			"url":  fullURL,
    			"path": path,
    		}
    	}
    
    	url, ok := downloadInfo["url"].(string)
    	if !ok {
    		continue
    	}
    	path, ok := downloadInfo["path"].(string)
    	if !ok {
    		continue
    	}
    	expectedHash, _ := downloadInfo["sha1"].(string)
    
    	filePath := filepath.Join(l.minelauncherPath, "libraries", filepath.FromSlash(path))
    	absFilePath, err := filepath.Abs(filePath)
    	if err != nil {
    		fmt.Printf("Не удалось получить абсолютный путь для файла %s: %v\n", filePath, err)
    		continue
    	}
    	dir := filepath.Dir(absFilePath)
    	os.MkdirAll(dir, os.ModePerm)
    
    	// Проверяем, существует ли файл и совпадает ли хэш
    	if _, err := os.Stat(absFilePath); err == nil {
    		if expectedHash != "" && l.verifyFileChecksum(absFilePath, expectedHash) {
    			continue
    		} else {
    			fmt.Printf("Хэш библиотеки не совпадает, перезагружаем файл: %s\n", absFilePath)
    			os.Remove(absFilePath)
    		}
    	}
    
    	wg.Add(1)
    	semaphore <- struct{}{}
    
    	go func(url, absFilePath, expectedHash string) {
    		defer wg.Done()
    		defer func() { <-semaphore }()
    
    		err := l.downloadFileWithRetry(url, absFilePath, 4)
    		if err != nil {
    			fmt.Printf("Ошибка при скачивании библиотеки %s: %v\n", url, err)
    			return
    		}
    
    		if expectedHash != "" && !l.verifyFileChecksum(absFilePath, expectedHash) {
    			fmt.Printf("Хэш библиотеки не совпадает после загрузки: %s\n", absFilePath)
    			os.Remove(absFilePath)
    		}
    	}(url, absFilePath, expectedHash)
    }
    wg.Wait()
    return nil
    

    }

    func (l *Launcher) mavenArtifactPath(name string) string { parts := strings.Split(name, ":") if len(parts) < 3 { return "" } groupID := parts[0] artifactID := parts[1] version := parts[2] classifier := "" if len(parts) > 3 { classifier = "-" + parts[3] } path := fmt.Sprintf("%s/%s/%s/%s-%s%s.jar", strings.ReplaceAll(groupID, ".", "/"), artifactID, version, artifactID, version, classifier) return path }

    func (l *Launcher) downloadAssets(versionData VersionData) error { fmt.Println("Скачивание ассетов...") assetIndex, ok := versionData["assetIndex"].(map[string]interface{}) if !ok { return fmt.Errorf("не удалось найти assetIndex в данных версии") } url, ok := assetIndex["url"].(string) if !ok { return fmt.Errorf("не удалось получить URL assetIndex") } expectedHash, ok := assetIndex["sha1"].(string) if !ok { return fmt.Errorf("не удалось получить sha1 assetIndex") }

    // Скачиваем индекс ассетов
    fmt.Println("Скачивание индекса ассетов...")
    resp, err := http.Get(url)
    if err != nil {
    	return fmt.Errorf("не удалось скачать индекс ассетов: %v", err)
    }
    defer resp.Body.Close()
    
    if resp.StatusCode != http.StatusOK {
    	return fmt.Errorf("не удалось скачать индекс ассетов, статус код: %d", resp.StatusCode)
    }
    
    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
    	return fmt.Errorf("не удалось прочитать индекс ассетов: %v", err)
    }
    
    hash := sha1.New()
    hash.Write(bodyBytes)
    calculatedHash := hex.EncodeToString(hash.Sum(nil))
    if expectedHash != calculatedHash {
    	return fmt.Errorf("хэш индекса ассетов не совпадает (ожидалось: %s, получено: %s)", expectedHash, calculatedHash)
    }
    
    var assetIndexData map[string]interface{}
    err = json.Unmarshal(bodyBytes, &assetIndexData)
    if err != nil {
    	return fmt.Errorf("ошибка при разборе индекса ассетов: %v", err)
    }
    
    fmt.Println("Сохранение индекса ассетов...")
    assetsDir := filepath.Join(l.minelauncherPath, "assets", "indexes")
    os.MkdirAll(assetsDir, os.ModePerm)
    indexFilePath := filepath.Join(assetsDir, fmt.Sprintf("%s.json", assetIndex["id"].(string)))
    err = os.WriteFile(indexFilePath, bodyBytes, 0644)
    if err != nil {
    	return fmt.Errorf("ошибка при сохранении индекса ассетов: %v", err)
    }
    
    objects, ok := assetIndexData["objects"].(map[string]interface{})
    if !ok {
    	return fmt.Errorf("не удалось получить объекты ассетов")
    }
    
    totalAssets := len(objects)
    fmt.Printf("Всего ассетов для загрузки: %d\n", totalAssets)
    
    var wg sync.WaitGroup
    semaphore := make(chan struct{}, 20)
    
    currentAsset := 0
    mutex := &sync.Mutex{}
    
    for _, obj := range objects {
    	wg.Add(1)
    	semaphore <- struct{}{}
    
    	go func(obj interface{}) {
    		defer wg.Done()
    		defer func() { <-semaphore }()
    
    		objInfo, ok := obj.(map[string]interface{})
    		if !ok {
    			return
    		}
    		hashStr, ok := objInfo["hash"].(string)
    		if !ok {
    			return
    		}
    		sizeFloat, ok := objInfo["size"].(float64)
    		if !ok {
    			return
    		}
    		size := int64(sizeFloat)
    		if len(hashStr) < 2 {
    			fmt.Printf("Некорректный хэш ассета: %s\n", hashStr)
    			return
    		}
    		subHash := hashStr[:2]
    
    		assetURL := fmt.Sprintf("https://resources.download.minecraft.net/%s/%s", subHash, hashStr)
    		filePath := filepath.Join(l.minelauncherPath, "assets", "objects", subHash, hashStr)
    		absFilePath, err := filepath.Abs(filePath)
    		if err != nil {
    			fmt.Printf("Не удалось получить абсолютный путь для ассета %s: %v\n", filePath, err)
    			return
    		}
    		dir := filepath.Dir(absFilePath)
    		os.MkdirAll(dir, os.ModePerm)
    
    		if fi, err := os.Stat(absFilePath); err == nil && fi.Size() == size {
    		} else {
    			err := l.downloadFileWithRetry(assetURL, absFilePath, 4)
    			if err != nil {
    				fmt.Printf("\nОшибка при скачивании ассета %s: %v\n", assetURL, err)
    				return
    			}
    		}
    
    		mutex.Lock()
    		currentAsset++
    		progress := float64(currentAsset) / float64(totalAssets) * 100
    		fmt.Printf("\rСкачивание ассетов: %d/%d (%.2f%%)", currentAsset, totalAssets, progress)
    		mutex.Unlock()
    	}(obj)
    }
    
    wg.Wait()
    fmt.Println("\nЗагрузка ассетов завершена.")
    return nil
    

    }

    func (l *Launcher) extractNatives(versionData VersionData, nativesDir string) error { fmt.Println("Извлечение нативных библиотек...") libraries, ok := versionData["libraries"].([]interface{}) if !ok { return fmt.Errorf("не удалось получить библиотеки для распаковки нативов") }

    for _, lib := range libraries {
    	libInfo, ok := lib.(map[string]interface{})
    	if !ok {
    		continue
    	}
    
    	if !l.shouldIncludeLibrary(libInfo) {
    		continue
    	}
    
    	downloads, ok := libInfo["downloads"].(map[string]interface{})
    	if !ok {
    		continue
    	}
    
    	classifiers, ok := downloads["classifiers"].(map[string]interface{})
    	if !ok {
    		continue
    	}
    
    	classifierName := l.getNatives(libInfo)
    	if classifierName == "" {
    		continue
    	}
    
    	native, ok := classifiers[classifierName].(map[string]interface{})
    	if !ok {
    		continue
    	}
    
    	url, ok := native["url"].(string)
    	if !ok {
    		continue
    	}
    	path, ok := native["path"].(string)
    	if !ok {
    		continue
    	}
    	expectedHash, _ := native["sha1"].(string)
    
    	filePath := filepath.Join(l.minelauncherPath, "libraries", filepath.FromSlash(path))
    	absFilePath, err := filepath.Abs(filePath)
    	if err != nil {
    		fmt.Printf("Не удалось получить абсолютный путь для файла %s: %v\n", filePath, err)
    		continue
    	}
    	dir := filepath.Dir(absFilePath)
    	os.MkdirAll(dir, os.ModePerm)
    
    	if _, err := os.Stat(absFilePath); err == nil {
    		if expectedHash != "" && l.verifyFileChecksum(absFilePath, expectedHash) {
    			fmt.Printf("Нативная библиотека уже существует и корректна: %s\n", absFilePath)
    		} else {
    			fmt.Printf("Хэш нативной библиотеки не совпадает, перезагружаем файл: %s\n", absFilePath)
    			os.Remove(absFilePath)
    		}
    	}
    
    	if _, err := os.Stat(absFilePath); os.IsNotExist(err) {
    		fmt.Printf("Скачивание нативной библиотеки: %s\n", absFilePath)
    		err := l.downloadFileWithRetry(url, absFilePath, 4)
    		if err != nil {
    			fmt.Printf("Ошибка при скачивании нативной библиотеки %s: %v\n", url, err)
    			return err
    		}
    	}
    
    	if expectedHash != "" && !l.verifyFileChecksum(absFilePath, expectedHash) {
    		return fmt.Errorf("хэш нативной библиотеки не совпадает после загрузки: %s", absFilePath)
    	}
    
    	fmt.Printf("Распаковка нативных библиотек из %s в %s\n", absFilePath, nativesDir)
    	err = l.unzip(absFilePath, nativesDir)
    	if err != nil {
    		return fmt.Errorf("ошибка при распаковке нативной библиотеки %s: %v", absFilePath, err)
    	}
    }
    
    return nil
    

    }

    func (l *Launcher) buildClasspath(versionData VersionData, versionID string) string { var classpath []string

    libraries, ok := versionData["libraries"].([]interface{})
    if !ok {
    	fmt.Println("Не удалось получить библиотеки для classpath")
    	return ""
    }
    
    librarySet := make(map[string]struct{}) // Для избежания дублирования
    
    for _, lib := range libraries {
    	libInfo, ok := lib.(map[string]interface{})
    	if !ok {
    		continue
    	}
    	if !l.shouldIncludeLibrary(libInfo) {
    		continue
    	}
    	var libPath string
    
    	downloads, hasDownloads := libInfo["downloads"].(map[string]interface{})
    	if hasDownloads {
    		artifact, hasArtifact := downloads["artifact"].(map[string]interface{})
    		if hasArtifact {
    			path, ok := artifact["path"].(string)
    			if !ok {
    				continue
    			}
    			libPath = filepath.Join("libraries", filepath.FromSlash(path))
    		}
    	} else {
    		// Обработка старого формата
    		name, ok := libInfo["name"].(string)
    		if !ok {
    			continue
    		}
    		path := l.mavenArtifactPath(name)
    		libPath = filepath.Join("libraries", filepath.FromSlash(path))
    	}
    
    	if libPath != "" {
    		if _, exists := librarySet[libPath]; !exists {
    			librarySet[libPath] = struct{}{}
    			classpath = append(classpath, libPath)
    		}
    	}
    }
    
    clientJar := filepath.Join("versions", versionID, versionID+".jar")
    classpath = append(classpath, clientJar)
    
    return strings.Join(classpath, string(os.PathListSeparator))
    

    }

    func (l *Launcher) replaceVariables(arg, username, versionID string, versionData VersionData, uuid, authToken string) string { assetIndex := l.versionDataGetAssetIndex(versionData)

    arg = strings.ReplaceAll(arg, "${auth_player_name}", username)
    arg = strings.ReplaceAll(arg, "${version_name}", versionID)
    arg = strings.ReplaceAll(arg, "${game_directory}", l.minelauncherPath)
    arg = strings.ReplaceAll(arg, "${assets_root}", filepath.Join(l.minelauncherPath, "assets"))
    arg = strings.ReplaceAll(arg, "${assets_index_name}", l.getAssetIndexName(assetIndex))
    arg = strings.ReplaceAll(arg, "${auth_uuid}", uuid)
    arg = strings.ReplaceAll(arg, "${auth_access_token}", authToken)
    arg = strings.ReplaceAll(arg, "${clientid}", "")
    arg = strings.ReplaceAll(arg, "${auth_xuid}", "")
    arg = strings.ReplaceAll(arg, "${version_type}", l.versionDataGetVersionType(versionData))
    arg = strings.ReplaceAll(arg, "${user_type}", "legacy")
    arg = strings.ReplaceAll(arg, "--demo", "")
    arg = strings.ReplaceAll(arg, "${natives_directory}", filepath.Join(l.minelauncherPath, "versions", versionID, "natives"))
    arg = strings.ReplaceAll(arg, "${launcher_name}", "MyCustomLauncher")
    arg = strings.ReplaceAll(arg, "${launcher_version}", "1.0")
    
    // Устанавливаем значения разрешения (ширины и высоты)
    resolutionWidth := "854"  // Значение ширины по умолчанию
    resolutionHeight := "480" // Значение высоты по умолчанию
    
    if resolutionWidth != "" {
    	arg = strings.ReplaceAll(arg, "${resolution_width}", resolutionWidth)
    } else {
    	// Удаляем опцию '--width' и ее значение из аргументов
    	arg = strings.ReplaceAll(arg, "--width ${resolution_width}", "")
    }
    
    if resolutionHeight != "" {
    	arg = strings.ReplaceAll(arg, "${resolution_height}", resolutionHeight)
    } else {
    	// Удаляем опцию '--height' и ее значение из аргументов
    	arg = strings.ReplaceAll(arg, "--height ${resolution_height}", "")
    }
    
    return arg
    

    }

    func (l *Launcher) getAssetIndexName(assetIndex map[string]interface{}) string { if id, ok := assetIndex["id"].(string); ok { return id } return "legacy" }

    func (l *Launcher) versionDataGetAssetIndex(versionData VersionData) map[string]interface{} { if assetIndex, ok := versionData["assetIndex"].(map[string]interface{}); ok { return assetIndex } return map[string]interface{}{} }

    func (l *Launcher) versionDataGetVersionType(versionData VersionData) string { if versionType, ok := versionData["type"].(string); ok { return versionType } return "release" }

    func (l *Launcher) checkRule(rules []interface{}) bool { allowed := false for _, ruleInterface := range rules { rule, ok := ruleInterface.(map[string]interface{}) if !ok { continue } action, ok := rule["action"].(string) if !ok { continue }

    	applies := true
    
    	if osDict, ok := rule["os"].(map[string]interface{}); ok {
    		osName := runtime.GOOS
    		if osName == "darwin" {
    			osName = "osx"
    		}
    		if name, ok := osDict["name"].(string); ok && name != osName {
    			applies = false
    		}
    	}
    
    	if applies {
    		if action == "allow" {
    			allowed = true
    		} else if action == "disallow" {
    			allowed = false
    		}
    	}
    }
    return allowed
    

    }

    func (l *Launcher) buildGameArguments(versionData VersionData, username, versionID, uuid, authToken string) []string { var args []string

    if arguments, ok := versionData["arguments"].(map[string]interface{}); ok {
    	if gameArgsList, ok := arguments["game"].([]interface{}); ok {
    		for _, arg := range gameArgsList {
    			switch arg := arg.(type) {
    			case string:
    				if strings.Contains(strings.ToLower(arg), "quickplay") {
    					continue
    				}
    				arg = l.replaceVariables(arg, username, versionID, versionData, uuid, authToken)
    				args = append(args, arg)
    			case map[string]interface{}:
    				if rules, ok := arg["rules"].([]interface{}); ok {
    					if l.checkRule(rules) {
    						if value, ok := arg["value"].(interface{}); ok {
    							args = l.appendArgumentValueWithoutQuickPlay(args, value, username, versionID, versionData, uuid, authToken)
    						}
    					}
    				} else {
    					if value, ok := arg["value"].(interface{}); ok {
    						args = l.appendArgumentValueWithoutQuickPlay(args, value, username, versionID, versionData, uuid, authToken)
    					}
    				}
    			}
    		}
    	}
    } else if minecraftArguments, ok := versionData["minecraftArguments"].(string); ok {
    	splitArgs := strings.Split(minecraftArguments, " ")
    	for _, arg := range splitArgs {
    		if strings.Contains(strings.ToLower(arg), "quickplay") {
    			continue
    		}
    		arg = l.replaceVariables(arg, username, versionID, versionData, uuid, authToken)
    		args = append(args, arg)
    	}
    }
    
    return args
    

    }

    func (l *Launcher) appendArgumentValueWithoutQuickPlay(args []string, value interface{}, username, versionID string, versionData VersionData, uuid, authToken string) []string { switch v := value.(type) { case string: if strings.Contains(strings.ToLower(v), "quickplay") { return args } v = l.replaceVariables(v, username, versionID, versionData, uuid, authToken) args = append(args, v) case []interface{}: for _, item := range v { if sv, ok := item.(string); ok { if strings.Contains(strings.ToLower(sv), "quickplay") { continue } sv = l.replaceVariables(sv, username, versionID, versionData, uuid, authToken) args = append(args, sv) } } } return args }

    func (l *Launcher) buildJvmArguments(versionData VersionData, nativesDir string) []string { var args []string

    // Добавляем стандартные JVM аргументы
    args = append(args, "-Djava.library.path="+nativesDir)
    args = append(args, "-Xmx1G")   // Максимальный объем памяти
    args = append(args, "-Xms512M") // Минимальный объем памяти
    
    if arguments, ok := versionData["arguments"].(map[string]interface{}); ok {
    	if jvmArgsList, ok := arguments["jvm"].([]interface{}); ok {
    		for _, arg := range jvmArgsList {
    			switch arg := arg.(type) {
    			case string:
    				arg = l.replaceVariables(arg, "", "", versionData, "", "")
    				args = append(args, arg)
    			case map[string]interface{}:
    				if rules, ok := arg["rules"].([]interface{}); ok {
    					if l.checkRule(rules) {
    						if value, ok := arg["value"].(interface{}); ok {
    							args = l.appendJvmArgumentValue(args, value, versionData)
    						}
    					}
    				} else {
    					if value, ok := arg["value"].(interface{}); ok {
    						args = l.appendJvmArgumentValue(args, value, versionData)
    					}
    				}
    			}
    		}
    	}
    }
    
    return args
    

    }

    func (l *Launcher) appendJvmArgumentValue(args []string, value interface{}, versionData VersionData) []string { switch v := value.(type) { case string: v = l.replaceVariables(v, "", "", versionData, "", "") args = append(args, v) case []interface{}: for _, item := range v { if sv, ok := item.(string); ok { sv = l.replaceVariables(sv, "", "", versionData, "", "") args = append(args, sv) } } } return args }

    func (l *Launcher) launchMinecraft(versionData VersionData, authToken, username, uuid, versionID string) error { fmt.Println("Запуск Minecraft...") mainClass, ok := versionData["mainClass"].(string) if !ok { return fmt.Errorf("не удалось найти mainClass в данных версии") } fmt.Println("Main class:", mainClass) classpath := l.buildClasspath(versionData, versionID) fmt.Println("Classpath длина:", len(classpath))

    if classpath == "" {
    	return fmt.Errorf("classpath пустой")
    }
    
    nativesDir := filepath.Join(l.minelauncherPath, "versions", versionID, "natives")
    absNativesDir, err := filepath.Abs(nativesDir)
    if err != nil {
    	return fmt.Errorf("не удалось получить абсолютный путь для nativesDir %s: %v", nativesDir, err)
    }
    os.MkdirAll(absNativesDir, os.ModePerm)
    
    // Распаковка нативных библиотек
    err = l.extractNatives(versionData, absNativesDir)
    if err != nil {
    	return fmt.Errorf("ошибка при извлечении нативных библиотек: %v", err)
    }
    
    // Build JVM and game arguments
    jvmArgs := l.buildJvmArguments(versionData, absNativesDir)
    gameArgs := l.buildGameArguments(versionData, username, versionID, uuid, authToken)
    
    if len(gameArgs) == 0 {
    	return fmt.Errorf("аргументы игры пустые")
    }
    
    // Combine all arguments
    args := append(jvmArgs, "-cp", classpath, mainClass)
    args = append(args, gameArgs...)
    
    // Write arguments to a temporary file
    argsFilePath := filepath.Join(os.TempDir(), "minecraft_args.txt")
    err = l.writeArgsToFile(argsFilePath, args)
    if err != nil {
    	return fmt.Errorf("ошибка при создании файла аргументов: %v", err)
    }
    
    // Prepare the command to use the argument file
    cmd := exec.Command("java", "@"+argsFilePath)
    cmd.Dir = l.minelauncherPath
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    
    fmt.Println("Команда запуска: java @" + argsFilePath)
    
    err = cmd.Run()
    if err != nil {
    	return fmt.Errorf("ошибка при запуске Minecraft: %v", err)
    }
    
    return nil
    

    }

    func (l *Launcher) writeArgsToFile(filePath string, args []string) error { var contentBuilder strings.Builder for _, arg := range args { arg = strings.ReplaceAll(arg, "\", "\\") arg = strings.ReplaceAll(arg, ", \")

    	if strings.ContainsAny(arg, " \t\n\"") {
    		arg = `"` + arg + `"`
    	}
    
    	contentBuilder.WriteString(arg)
    	contentBuilder.WriteString(" ")
    }
    
    content := contentBuilder.String()
    return os.WriteFile(filePath, []byte(content), 0644)
    

    }

    func (l *Launcher) verifyAllFiles(versionData VersionData, versionID string) error { fmt.Println("Проверка наличия всех необходимых файлов...") clientJar := filepath.Join(l.minelauncherPath, "versions", versionID, versionID+".jar") if _, err := os.Stat(clientJar); os.IsNotExist(err) { return fmt.Errorf("клиентский JAR-файл отсутствует: %s", clientJar) }

    libraries, ok := versionData["libraries"].([]interface{})
    if !ok {
    	return fmt.Errorf("не удалось получить библиотеки для проверки")
    }
    for _, lib := range libraries {
    	libInfo, ok := lib.(map[string]interface{})
    	if !ok {
    		continue
    	}
    	if !l.shouldIncludeLibrary(libInfo) {
    		continue
    	}
    	var libPath string
    
    	downloads, hasDownloads := libInfo["downloads"].(map[string]interface{})
    	if hasDownloads {
    		artifact, hasArtifact := downloads["artifact"].(map[string]interface{})
    		if hasArtifact {
    			path, ok := artifact["path"].(string)
    			if !ok {
    				continue
    			}
    			libPath = filepath.Join(l.minelauncherPath, "libraries", filepath.FromSlash(path))
    		}
    	} else {
    		// Обработка старого формата
    		name, ok := libInfo["name"].(string)
    		if !ok {
    			continue
    		}
    		path := l.mavenArtifactPath(name)
    		libPath = filepath.Join(l.minelauncherPath, "libraries", filepath.FromSlash(path))
    	}
    
    	if libPath == "" {
    		fmt.Printf("Пустой путь для библиотеки: %+v\n", libInfo)
    		continue
    	}
    
    	if _, err := os.Stat(libPath); os.IsNotExist(err) {
    		return fmt.Errorf("отсутствует библиотека: %s", libPath)
    	}
    }
    
    fmt.Println("Все необходимые файлы присутствуют.")
    return nil
    

    }

    func (l *Launcher) generateOfflineUUID() string { uuid := make([]byte, 16) _, err := rand.Read(uuid) if err != nil { panic(err) }

    uuid[6] = (uuid[6] & 0x0F) | 0x40
    uuid[8] = (uuid[8] & 0x3F) | 0x80
    
    return fmt.Sprintf("%x-%x-%x-%x-%x",
    	uuid[0:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:])
    

    }

    func (l *Launcher) PlayMinecraftVersion(versionID string, username string) error { absPath, err := filepath.Abs(l.minelauncherPath) if err != nil { return fmt.Errorf("не удалось получить абсолютный путь для %s: %v", l.minelauncherPath, err) } l.minelauncherPath = absPath

    err = os.MkdirAll(l.minelauncherPath, os.ModePerm)
    if err != nil {
    	return fmt.Errorf("не удалось создать директорию %s: %v", l.minelauncherPath, err)
    }
    
    versionData, err := l.getVersionDetails(versionID)
    if err != nil {
    	return err
    }
    
    // Объединяем данные версий с учетом inheritsFrom
    versionData, err = l.mergeVersionData(versionData)
    if err != nil {
    	return err
    }
    
    versionDir := filepath.Join(l.minelauncherPath, "versions", versionID)
    err = os.MkdirAll(versionDir, os.ModePerm)
    if err != nil {
    	return fmt.Errorf("не удалось создать директорию %s: %v", versionDir, err)
    }
    versionJsonPath := filepath.Join(versionDir, versionID+".json")
    
    versionDataBytes, err := json.MarshalIndent(versionData, "", "  ")
    if err != nil {
    	return fmt.Errorf("ошибка при сериализации данных версии: %v", err)
    }
    
    err = os.WriteFile(versionJsonPath, versionDataBytes, 0644)
    if err != nil {
    	return fmt.Errorf("ошибка при сохранении файла version.json: %v", err)
    }
    
    err = l.downloadClientJar(versionData, versionID)
    if err != nil {
    	return fmt.Errorf("ошибка при скачивании клиентского JAR-файла: %v", err)
    }
    
    err = l.downloadLibraries(versionData)
    if err != nil {
    	return fmt.Errorf("ошибка при скачивании библиотек: %v", err)
    }
    
    err = l.downloadAssets(versionData)
    if err != nil {
    	return fmt.Errorf("ошибка при скачивании ассетов: %v", err)
    }
    
    err = l.verifyAllFiles(versionData, versionID)
    if err != nil {
    	return fmt.Errorf("ошибка валидации файлов: %v", err)
    }
    
    dirs := []string{
    	filepath.Join(l.minelauncherPath, "saves"),
    	filepath.Join(l.minelauncherPath, "resourcepacks"),
    	filepath.Join(l.minelauncherPath, "logs"),
    	filepath.Join(l.minelauncherPath, "runtime"),
    }
    for _, dir := range dirs {
    	err := os.MkdirAll(dir, os.ModePerm)
    	if err != nil {
    		return fmt.Errorf("не удалось создать директорию %s: %v", dir, err)
    	}
    }
    
    optionsFilePath := filepath.Join(l.minelauncherPath, "options.txt")
    if _, err := os.Stat(optionsFilePath); os.IsNotExist(err) {
    	err := os.WriteFile(optionsFilePath, []byte(""), 0644)
    	if err != nil {
    		return fmt.Errorf("не удалось создать файл %s: %v", optionsFilePath, err)
    	}
    }
    
    javaVersionCmd := exec.Command("java", "-version")
    javaVersionOutput, err := javaVersionCmd.CombinedOutput()
    if err != nil {
    	return fmt.Errorf("ошибка при проверке версии Java: %v", err)
    }
    fmt.Println("Java версия:", string(javaVersionOutput))
    
    uname := username
    uuid := l.generateOfflineUUID()
    authToken := ""
    
    err = l.launchMinecraft(versionData, authToken, uname, uuid, versionID)
    if err != nil {
    	return fmt.Errorf("ошибка при запуске Minecraft: %v", err)
    }
    
    fmt.Println("Minecraft запущен успешно!")
    return nil
    

    }

    [18:09:01] [Render thread/INFO]: Environment: authHost='https://authserver.mojang.com', accountsHost='https://api.mojang.com', sessionHost='https://sessionserver.mojang.com', servicesHost='https://api.minecraftservices.com', name='PROD' [18:09:02] [Render thread/INFO]: Setting user: MAKAR566 [18:09:02] [Render thread/INFO]: Backend library: LWJGL version 3.2.1 build 12 [18:09:02] [Render thread/INFO]: [STDERR]: [LWJGL] [ERROR] Incompatible Java and native library versions detected. Possible reasons: a) -Djava.library.path is set to a folder containing shared libraries of an older LWJGL version. b) The classpath contains jar files of an older LWJGL version. Possible solutions: a) Make sure to not set -Djava.library.path (it is not needed for developing with LWJGL 3) or make sure the folder it points to contains the shared libraries of the correct LWJGL version. b) Check the classpath and make sure to only have jar files of the same LWJGL version in it. [18:09:02] [Render thread/INFO]: [STDERR]: [LWJGL] [ThreadLocalUtil] Unsupported JNI version detected, this may result in a crash. Please inform LWJGL developers.

    A fatal error has been detected by the Java Runtime Environment:

    EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00007ff97510cb76, pid=30944, tid=11256

    JRE version: Java(TM) SE Runtime Environment (21.0.4+8) (build 21.0.4+8-LTS-274)

    Java VM: Java HotSpot(TM) 64-Bit Server VM (21.0.4+8-LTS-274, mixed mode, sharing, tiered, compressed oops, compressed class ptrs, g1 gc, windows-amd64)

    Problematic frame:

    V [jvm.dll+0x43cb76]

    No core dump will be written. Minidumps are not enabled by default on client versions of Windows

    An error report file with more information is saved as:

    D:\JBProjects\GOLAND\MineLauncherTest.legit\hs_err_pid30944.log

    If you would like to submit a bug report, please visit:

    https://bugreport.java.com/bugreport/crash.jsp

    panic: ошибка при запуске Minecraft: ошибка при запуске Minecraft: exit status 1

    goroutine 1 [running]: main.main() D:/JBProjects/GOLAND/MineLauncherTest/main.go:31 +0x259

    при запуске 1.16.5 выходит эта ошибка исправь это сделай так чтобы этой ошибки не было все версии длжны поддреживатьс

  2. Assistant

    The error you’re encountering when launching Minecraft 1.16.5 is primarily due to Java version incompatibility. Minecraft versions, especially older ones like 1.16.5, are optimized to run with specific Java versions. Running them with newer Java versions (e.g., Java 21) can lead to issues such as the one you're experiencing with LWJGL (Lightweight Java Game Library) incompatibilities.

    Here’s a step-by-step guide to resolve this issue and ensure compatibility across all Minecraft versions you intend to support.

    1. Understand the Root Cause

    Java Version Incompatibility

    • Minecraft 1.16.5: Officially recommends Java 8. While it can work with newer versions, some libraries and dependencies (like LWJGL) might not be fully compatible.
    • Error Details:
      [LWJGL] [ERROR] Incompatible Java and native library versions detected.
      
      This indicates that the native libraries loaded by LWJGL are not compatible with the Java version you’re using.

    LWJGL Version Mismatch

    • Your launcher is fetching LWJGL 3.2.1, but Minecraft 1.16.5 requires LWJGL 3.2.2.
    • The mismatch between these versions can cause the JNI (Java Native Interface) error leading to crashes.

    2. Implementing a Solution in Your Launcher

    To make your launcher support all Minecraft versions without such errors, you need to:

    1. Use the Correct Java Version for Each Minecraft Version.
    2. Ensure LWJGL and Other Libraries Match the Requirements of Each Minecraft Version.

    Step-by-Step Implementation

    A. Modify the Launcher to Use Specific Java Versions

    1. Bundle Multiple Java Versions:

      • Include different Java Runtime Environments (JREs) with your launcher.
      • For example, bundle Java 8 for older Minecraft versions and Java 17 or later for newer ones.
    2. Detect the Required Java Version:

      • Fetch the javaVersion specified in the Minecraft version's JSON data.
      • If not specified, default to Java 8 for versions before certain milestones.
    3. Set the Java Executable Path Based on the Version:

      • Allow your launcher to switch between different Java executables based on the Minecraft version being launched.

    B. Update Your Launcher Code

    Below is an updated version of your PlayMinecraftVersion method with enhancements to support multiple Java versions and resolve the LWJGL incompatibility.

    package launcher
    
    // ... [other imports remain the same]
    
    type Launcher struct {
        minelauncherPath string
        versionManifest  *VersionManifest
        javaPaths        map[string]string // Mapping from Java version to its executable path
    }
    
    // NewLauncher initializes the launcher with default paths
    func NewLauncher() *Launcher {
        return &Launcher{
            minelauncherPath: ".minecraft",
            javaPaths: map[string]string{
                "8":  "java8/bin/java.exe", // Path to Java 8 executable
                "17": "java17/bin/java.exe", // Path to Java 17 executable
                // Add more Java versions as needed
            },
        }
    }
    
    // SetJavaPath allows setting custom Java executable paths
    func (l *Launcher) SetJavaPath(javaVersion, path string) {
        l.javaPaths[javaVersion] = path
    }
    
    // getJavaExecutable selects the appropriate Java executable based on the Minecraft version
    func (l *Launcher) getJavaExecutable(versionID string, versionData VersionData) (string, error) {
        // Determine required Java version from versionData
        // Many older versions use Java 8. Newer versions might use Java 16+
        // For simplicity, let's assume versions <= 1.16.5 use Java 8, others use Java 17
        // You can enhance this with more precise data if available
    
        requiredJava := "8" // Default to Java 8
    
        // Example logic: adjust based on versionID or versionData
        if strings.Compare(versionID, "1.17") >= 0 {
            requiredJava = "17"
        }
    
        javaPath, exists := l.javaPaths[requiredJava]
        if !exists {
            return "", fmt.Errorf("Java version %s is not configured in the launcher", requiredJava)
        }
    
        // Verify that the Java executable exists
        if _, err := os.Stat(javaPath); os.IsNotExist(err) {
            return "", fmt.Errorf("Java executable not found at path: %s", javaPath)
        }
    
        return javaPath, nil
    }
    
    // launchMinecraft now uses the appropriate Java executable
    func (l *Launcher) launchMinecraft(versionData VersionData, authToken, username, uuid, versionID string) error {
        fmt.Println("Запуск Minecraft...")
        mainClass, ok := versionData["mainClass"].(string)
        if !ok {
            return fmt.Errorf("не удалось найти mainClass в данных версии")
        }
        fmt.Println("Main class:", mainClass)
        classpath := l.buildClasspath(versionData, versionID)
        fmt.Println("Classpath длина:", len(classpath))
    
        if classpath == "" {
            return fmt.Errorf("classpath пустой")
        }
    
        nativesDir := filepath.Join(l.minelauncherPath, "versions", versionID, "natives")
        absNativesDir, err := filepath.Abs(nativesDir)
        if err != nil {
            return fmt.Errorf("не удалось получить абсолютный путь для nativesDir %s: %v", nativesDir, err)
        }
        os.MkdirAll(absNativesDir, os.ModePerm)
    
        // Распаковка нативных библиотек
        err = l.extractNatives(versionData, absNativesDir)
        if err != nil {
            return fmt.Errorf("ошибка при извлечении нативных библиотек: %v", err)
        }
    
        // Build JVM and game arguments
        jvmArgs := l.buildJvmArguments(versionData, absNativesDir)
        gameArgs := l.buildGameArguments(versionData, username, versionID, uuid, authToken)
    
        if len(gameArgs) == 0 {
            return fmt.Errorf("аргументы игры пустые")
        }
    
        // Combine all arguments
        args := append(jvmArgs, "-cp", classpath, mainClass)
        args = append(args, gameArgs...)
    
        // Write arguments to a temporary file
        argsFilePath := filepath.Join(os.TempDir(), "minecraft_args.txt")
        err = l.writeArgsToFile(argsFilePath, args)
        if err != nil {
            return fmt.Errorf("ошибка при создании файла аргументов: %v", err)
        }
    
        // Select the appropriate Java executable
        javaExec, err := l.getJavaExecutable(versionID, versionData)
        if err != nil {
            return fmt.Errorf("ошибка при выборе Java: %v", err)
        }
    
        // Prepare the command to use the argument file
        cmd := exec.Command(javaExec, "@"+argsFilePath)
        cmd.Dir = l.minelauncherPath
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
    
        fmt.Printf("Команда запуска: %s @%s\n", javaExec, argsFilePath)
    
        err = cmd.Run()
        if err != nil {
            return fmt.Errorf("ошибка при запуске Minecraft: %v", err)
        }
    
        return nil
    }
    

    Explanation of the Changes

    1. Java Executable Mapping:

      • Added a javaPaths map to associate specific Java versions with their executable paths.
      • Example: "8": "java8/bin/java.exe" points to the Java 8 executable bundled in the java8 directory.
    2. Setting Java Paths:

      • SetJavaPath method allows you to configure custom paths for different Java versions.
    3. Java Executable Selection:

      • getJavaExecutable method determines which Java executable to use based on the Minecraft version.
      • Simplistic Logic: Assumes versions <= 1.16.5 use Java 8 and versions >= 1.17 use Java 17.
      • Enhancement Needed: For more precise control, retrieve the required Java version from the versionData if available.
    4. Launching with Specific Java:

      • Modified launchMinecraft to use the selected Java executable instead of the system default.
      • This ensures that each Minecraft version runs with the Java version it expects, preventing LWJGL and JNI compatibility issues.

    C. Bundle Required Java Versions

    Since older Java versions (like Java 8) might not be installed on modern systems, it's best to bundle them with your launcher:

    1. Download Java JREs:

      • Obtain Java 8 and Java 17 JREs.
      • Ensure you comply with their respective licenses when bundling.
    2. Include Them in Your Launcher Directory:

      • Place Java 8 in java8/ and Java 17 in java17/ within your launcher’s directory structure.
    3. Update Paths in the Launcher:

      • Ensure the javaPaths map in the launcher correctly references these bundled Java executables.

    D. Adjust LWJGL Handling

    Ensure that the LWJGL version matches what’s expected by each Minecraft version:

    1. Fetch Correct LWJGL Version:

      • Parse the libraries section in the versionData to determine the required LWJGL version.
    2. Download and Include Specific LWJGL Versions:

      • When downloading libraries, ensure LWJGL versions are correctly fetched based on the version’s requirements.
    3. Verify Classpath Consistency:

      • Ensure only one LWJGL version is included in the classpath to prevent conflicts.

    Example: Setting Java Paths During Initialization

    func (l *Launcher) InitializeJavaPaths() {
        // Assuming Java executables are in "java8/bin/java.exe" and "java17/bin/java.exe"
        executablePath, err := os.Executable()
        if err != nil {
            panic(err)
        }
        launcherDir := filepath.Dir(executablePath)
    
        l.SetJavaPath("8", filepath.Join(launcherDir, "java8", "bin", "java.exe"))
        l.SetJavaPath("17", filepath.Join(launcherDir, "java17", "bin", "java.exe"))
    }
    

    Ensure you call InitializeJavaPaths during the launcher's initialization phase.

    3. Additional Recommendations

    A. Provide Clear Documentation to Users

    • Java Installation: Inform users that certain Minecraft versions require specific Java versions.
    • Automatic Java Management: Consider automating Java installation or bundling necessary JREs to simplify the user experience.

    B. Handle Java Absence Gracefully

    • Fallback Mechanism: If a required Java version isn't found, prompt the user to install it or download it automatically.
    • User Configuration: Allow users to specify custom Java paths in a configuration file or through the launcher interface.

    C. Enhance Error Handling and Logging

    • Detailed Logs: Ensure your launcher logs detailed information about Java versions and library loading processes.
    • User-Friendly Messages: Provide clear error messages guiding users to resolve issues, such as missing Java versions.

    D. Keep Libraries Updated

    • Regularly Update LWJGL: Ensure that the LWJGL versions your launcher uses are up-to-date and compatible with the latest Minecraft versions.
    • Version Synchronization: Synchronize library versions based on the version_manifest from Mojang to maintain compatibility.

    4. Testing

    After implementing the above changes:

    1. Test with Multiple Minecraft Versions:

      • Launch versions like 1.16.5 (using Java 8) and newer versions (using Java 17) to ensure compatibility.
    2. Verify LWJGL Compatibility:

      • Ensure that LWJGL libraries loaded match the expectations of each Minecraft version.
    3. Monitor for JNI Errors:

      • Run the launcher and check for any JNI-related errors in the logs to confirm that the issues are resolved.

    Conclusion

    The core issue was the incompatibility between the Java version (Java 21) you were using and the expected Java version for Minecraft 1.16.5. By adjusting your launcher to use the appropriate Java version for each Minecraft version, you can eliminate these incompatibility issues. Additionally, ensuring that all required libraries like LWJGL match the expectations of each Minecraft version will provide a smooth and error-free gaming experience.

    If you need further assistance with specific parts of the implementation or encounter additional errors, feel free to ask!