System respa RPG MZ

Jeśli chcesz podzielić się swoimi materiałami z innymi użytkownikami forum.

Moderatorzy: GameBoy, Dragon Kamillo

ODPOWIEDZ
Sędzimir
Posty: 1
Rejestracja: 30 gru 2024, 20:16

System respa RPG MZ

Post autor: Sędzimir »

Witam Przedstawiam wam mój system respienia się np. roślin. Jest to dość proste, tworzymy plik np. resp.js nawet w notatniku, dodajemy go do naszego folderu z gra w folder Plugins. Dodajemy i uruchamiamy go w grze, kiedy utworzysz zdarzenie z roślinką na mapie w polu Note wpisujesz "<respawn x><itemToAdd id>"
x = czas w s. do pojawienia się rośliny
id = nr. przedmiotu z gry w zakładce items (pomin zera)
Przykład:
<respawn 3><itemToAdd 2> co daje nam czas oczekiwania 3s. i przedmiot przypisany do nr.2
co zawiera kod:
-resp rzeczy możesz użyć tego do stworzenia roślin na mapie które po ustalonym czasie się zrespiom, każda może mieć swój indywidualny czas
-kod działa nawet jak zmienisz lokalizację na inna mapę
-kod działa i pamięta czas nawet po zapisaniu i uruchomieniu zapisu od nowa (rośliny które miały się pojawić się pojawią a te które muszą jeszcze poczekać będą czekały na upływ czasu)
-losowy resp rośliny nie pokaże się w tym samym miejscu po zebraniu (pokazuje się tylko na kafelkach po których można się poruszać)

Kod: Zaznacz cały

/*:
 /*:
 * @plugindesc System respu np. roślin na mapie.
 * @author Sędzimir
 */
 (function () {
    const RespawnManager = {
        _respawnData: {},
        _eventPositions: {}, // Przechowywanie pozycji wydarzeń

        // Generowanie klucza do zapisu
        getEventKey(mapId, eventId) {
            return `respawn_${mapId}_${eventId}`;
        },

        // Ustawianie czasu respawnu
        setRespawnTime(mapId, eventId, time) {
            const key = this.getEventKey(mapId, eventId);
            this._respawnData[key] = Date.now() + time * 1000;
        },

        // Ustawianie nowej pozycji wydarzenia
        setEventPosition(mapId, eventId, x, y) {
            const key = this.getEventKey(mapId, eventId);
            this._eventPositions[key] = { x, y };
        },

        // Pobieranie zapisanej pozycji wydarzenia
        getEventPosition(mapId, eventId) {
            const key = this.getEventKey(mapId, eventId);
            return this._eventPositions[key] || null;
        },

        // Sprawdzanie gotowości do respawnu
        isReadyToRespawn(mapId, eventId) {
            const key = this.getEventKey(mapId, eventId);
            const respawnTime = this._respawnData[key];
            return respawnTime && Date.now() >= respawnTime;
        },

        // Zapis danych respawnu
        saveRespawnData() {
            return {
                respawnData: this._respawnData,
                eventPositions: this._eventPositions,
            };
        },

        // Wczytanie danych respawnu
        loadRespawnData(data) {
            this._respawnData = data.respawnData || {};
            this._eventPositions = data.eventPositions || {};
        },
    };

    // Zapis do pliku gry
    const _DataManager_makeSaveContents = DataManager.makeSaveContents;
    DataManager.makeSaveContents = function () {
        const contents = _DataManager_makeSaveContents.call(this);
        contents.respawnData = RespawnManager.saveRespawnData();
        return contents;
    };

    // Wczytanie z pliku gry
    const _DataManager_extractSaveContents = DataManager.extractSaveContents;
    DataManager.extractSaveContents = function (contents) {
        _DataManager_extractSaveContents.call(this, contents);
        RespawnManager.loadRespawnData(contents.respawnData);
    };

    // Rozszerzenie Game_Event - wczytanie zapisanej pozycji
    const _Game_Event_initialize = Game_Event.prototype.initialize;
    Game_Event.prototype.initialize = function (mapId, eventId) {
        _Game_Event_initialize.call(this, mapId, eventId);

        const savedPosition = RespawnManager.getEventPosition(mapId, eventId);
        if (savedPosition) {
            this.locate(savedPosition.x, savedPosition.y); // Ustawienie zapisanej pozycji
        }
    };

    // Rozszerzenie setupPage - wczytywanie tagów notatek
    const _Game_Event_setupPage = Game_Event.prototype.setupPage;
    Game_Event.prototype.setupPage = function () {
        _Game_Event_setupPage.call(this);

        const respawnMatch = /<respawn (\d+)>/.exec(this.event().note);
        if (respawnMatch) {
            this._respawnTime = parseInt(respawnMatch[1], 10);
        }

        const itemMatch = /<itemToAdd (\d+)>/.exec(this.event().note);
        if (itemMatch) {
            this._itemToAdd = parseInt(itemMatch[1], 10);
        }
    };

    // Rozpoczęcie wydarzenia - obsługa respawnu i przedmiotów
    const _Game_Event_start = Game_Event.prototype.start;
    Game_Event.prototype.start = function () {
        _Game_Event_start.call(this);

        if (this._respawnTime) {
            RespawnManager.setRespawnTime($gameMap.mapId(), this.eventId(), this._respawnTime);
            this.setSelfSwitch("A", true); // Ukrycie wydarzenia
            this.setRandomRespawnPosition(); // Ustawienie losowej pozycji
        }

        if (this._itemToAdd) {
            const item = $dataItems[this._itemToAdd];
            if (item) {
                $gameParty.gainItem(item, 1); // Dodanie przedmiotu
                $gameMessage.add(`Otrzymałeś przedmiot: ${item.name}`);
            }
        }
    };

    // Ustawianie losowej pozycji wydarzenia
    Game_Event.prototype.setRandomRespawnPosition = function () {
        const mapWidth = $gameMap.width();
        const mapHeight = $gameMap.height();
        let newX, newY;

        do {
            newX = Math.floor(Math.random() * mapWidth);
            newY = Math.floor(Math.random() * mapHeight);
        } while (!$gameMap.isPassable(newX, newY, 2)); // Sprawdzenie przechodności

        this.locate(newX, newY);
        RespawnManager.setEventPosition($gameMap.mapId(), this.eventId(), newX, newY); // Zapisanie nowej pozycji
    };

    // Aktualizacja - tylko dla wydarzeń z tagiem respawnu
    const _Game_Map_update = Game_Map.prototype.update;
    Game_Map.prototype.update = function (sceneActive) {
        _Game_Map_update.call(this, sceneActive);

        $gameMap.events().forEach(event => {
            if (event._respawnTime && RespawnManager.isReadyToRespawn($gameMap.mapId(), event.eventId())) {
                event.setSelfSwitch("A", false); // Odtworzenie wydarzenia
                delete RespawnManager._respawnData[RespawnManager.getEventKey($gameMap.mapId(), event.eventId())];
            }
        });
    };

    // Ustawianie samoprzełącznika dla wydarzenia
    Game_Event.prototype.setSelfSwitch = function (switchName, value) {
        const key = [$gameMap.mapId(), this.eventId(), switchName];
        $gameSelfSwitches.setValue(key, value);
    };
})();

ODPOWIEDZ