[Plugin] Ajout sur système Jour/Nuit

Code:


//=============================================================================
// Day&Night_System.js
//=============================================================================

/*:
 * @plugindesc Système jour/nuit
 * @author Palbolsky & Gummy
 *
 * par Gummy - rpgmakervx-fr.com - v 1.0 - 01/2012
 * Grand merci à Cidiomar et Mist' pour leur aide.
 *
 * par Palbolsky - adaptation en plugin - v 1.0 - 13/03/2016
 * Grand merci à Sphinx pour son aide.
 *
 * @param Durée de l'aube
 * @desc Définissez la durée de l'aube en minutes (minimum 1 minute).
 * @default 1
 *
 * @param Durée du jour
 * @desc Définissez la durée du jour en minutes (minimum 1 minute).
 * @default 4
 *
 * @param Durée du crépuscule
 * @desc Définissez la durée du crépuscule en minutes (minimum 1 minute).
 * @default 1
 *
 * @param Durée de la nuit
 * @desc Définissez la durée de la nuit en minutes (minimum 1 minute).
 * @default 4
 *
 * @param Transition entre l'aube et le jour
 * @desc Définissez la durée de la transition entre l'aube et le jour en frames (60 frames = 1 sec)
 * @default 300
 *
 * @param Transition entre le jour et le crépuscule
 * @desc Définissez la durée de la transition entre le jour et le crépuscule en frames (60 frames = 1 sec)
 * @default 300
 *
 * @param Transition entre le crépuscule et la nuit
 * @desc Définissez la durée de la transition entre le crépuscule et la nuit en frames (60 frames = 1 sec)
 * @default 300
 *
 * @param Transition entre la nuit et l'aube
 * @desc Définissez la durée de la transition entre la nuit et l'aube en frames (60 frames = 1 sec)
 * @default 300
 *
 * @param Démarrage du timer
 * @desc Démarrer le timer en tant que JOUR (en tant que nuit si = false)
 * @default true
 *
 * @param Détection du temps
 * @desc Gère un interrupteur selon la période (ne gère pas si = false). Utile pour fermer les magasins la nuit, par exemple.
 * @default true
 *
 * @param ID de l'interrupteur pour la détection du temps
 * @desc Détermine l'interrupteur sur lequel opérer si TimeDetection est à true. Si interrupteur activé, alors c'est la nuit.
 * @default 1
 *
 * @param Ton de l'écran lors de l'aube
 * @desc Ordre des couleurs : Rouge, Vert, Bleu, Saturation
 * @default 0, -34, 22, 0
 *
 * @param Ton de l'écran lors du jour
 * @desc Ordre des couleurs : Rouge, Vert, Bleu, Saturation
 * @default 0, 0, 0, 0
 *
 * @param Ton de l'écran lors du crépuscule
 * @desc Ordre des couleurs : Rouge, Vert, Bleu, Saturation
 * @default 68, -34, -34, 0
 *
 * @param Ton de l'écran lors de la nuit
 * @desc Ordre des couleurs : Rouge, Vert, Bleu, Saturation
 * @default -68, -68, 0, -68
 *
 * @help
 * //==========================================================================
 * // Plugin : Day&Night_System
 * // Date   : 13 mars 2016
 * // Auteur : Palbolsky & Gummy
 * //==========================================================================
 * Ce plugin permet créer un système Jour/Nuit avec gestion de temps virtuel.
 *
 * Utiliser le gestionnaire de module pour configurer le système à votre
 * convenance.
 *
 * Pour ne pas afficher les tons de couleur dans des espaces intérieurs ou autre,
 * il suffit de mettre <in> dans la remarque des propriétés de la map.
 *
 */

//==============================================================================
// ? Day&Night_System : Time_Manager
//------------------------------------------------------------------------------
// Module de gestion du temps utilisé par le système Day&Night - par Gummy
// Adapté pour RMMV par Palbolsky
// rpgmakervx-fr.com
//==============================================================================
function Time_Manager() {}

// Ensemble des paramètres
Time_Manager.Parameters = PluginManager.parameters("Day&Night_System");

// Durée de l'aube en minutes
Time_Manager.Dawn_Length = parseInt(Time_Manager.Parameters["Durée de l'aube"], 10) || 1;

// Durée du jour en minutes
Time_Manager.Day_Length = parseInt(Time_Manager.Parameters["Durée du jour"], 10) || 4;

// Durée du crépuscule en minutes
Time_Manager.Twilight_Length = parseInt(Time_Manager.Parameters["Durée du crépuscule"], 10) || 1;

// Durée de la nuit en minutes
Time_Manager.Night_Length = parseInt(Time_Manager.Parameters["Durée de la nuit"], 10) || 4;

// Durée de la transition entre l'aube et le jour en frames (60 frames = 1 sec)
Time_Manager.Dawn_Transition = parseInt(Time_Manager.Parameters["Transition entre l'aube et le jour"], 10) || 300;

// Durée de la transition entre le jour et le crépuscule en frames (60 frames = 1 sec)
Time_Manager.Day_Transition = parseInt(Time_Manager.Parameters["Transition entre le jour et le crépuscule"], 10) || 300;

// Durée de la transition entre le crépuscule et la nuit en frames (60 frames = 1 sec)
Time_Manager.Twilight_Transition = parseInt(Time_Manager.Parameters["Transition entre le crépuscule et la nuit"], 10) || 300;

// Durée de la transition entre la nuit et l'aube en frames (60 frames = 1 sec)
Time_Manager.Night_Transition = parseInt(Time_Manager.Parameters["Transition entre la nuit et l'aube"], 10) || 300;

// Démarre le timer en tant que JOUR (en tant que nuit si = false)
Time_Manager.StartAtDay = Time_Manager.Parameters["Démarrage du timer"] === "true";

// Gère un interrupteur selon la période (ne gère pas si = false)
// Utile pour fermer les magasins la nuit, par exemple.
Time_Manager.TimeDetection = Time_Manager.Parameters["Détection du temps"] === "true";

// Détermine l'interrupteur sur lequel opérer si TimeDetection est à true.
// Si l'interrupteur est activé, alors c'est la nuit.
Time_Manager.Switch_ID = parseInt(Time_Manager.Parameters["ID de l'interrupteur pour la détection du temps"], 10) || 1;

// Ton de l'écran lors de l'aube (Rouge,Vert,Bleu,Saturation)
Time_Manager.Dawn_Tone_Default = [0, -34, 22, 0];
Time_Manager.Dawn_Tone = Time_Manager.Parameters["Ton de l'écran lors de l'aube"].split(",");

if (Time_Manager.Dawn_Tone instanceof Array) {
 if (Time_Manager.Dawn_Tone.length == 4) {
 var value;
 for(var i = 0 ; i < 4 ; i++) {
 value = parseInt(Time_Manager.Dawn_Tone[i], 10);
 if (isNaN(value)) {
 Time_Manager.Dawn_Tone = Time_Manager.Dawn_Tone_Default;
 break;
 }
 Time_Manager.Dawn_Tone[i] = value;
 }
 }
 else
 Time_Manager.Dawn_Tone = Time_Manager.Dawn_Tone_Default;
}
else
 Time_Manager.Dawn_Tone = Time_Manager.Dawn_Tone_Default;

// Ton de l'écran lors du jour (Rouge,Vert,Bleu,Saturation)
Time_Manager.Day_Tone_Default = [0, 0, 0, 0];
Time_Manager.Day_Tone = Time_Manager.Parameters["Ton de l'écran lors du jour"].split(",");

if (Time_Manager.Day_Tone instanceof Array) {
 if (Time_Manager.Day_Tone.length == 4) {
 var value;
 for(var i = 0 ; i < 4 ; i++) {
 value = parseInt(Time_Manager.Day_Tone[i], 10);
 if (isNaN(value)) {
 Time_Manager.Day_Tone = Time_Manager.Dawn_Tone_Default;
 break;
 }
 Time_Manager.Day_Tone[i] = value;
 }
 }
 else
 Time_Manager.Day_Tone = Time_Manager.Dawn_Tone_Default;
}
else
 Time_Manager.Day_Tone = Time_Manager.Dawn_Tone_Default;

// Ton de l'écran lors du crépuscule (Rouge,Vert,Bleu,Saturation)
Time_Manager.Twilight_Tone_Default = [68, -34, -34, 0];
Time_Manager.Twilight_Tone = Time_Manager.Parameters["Ton de l'écran lors du crépuscule"].split(",");

if (Time_Manager.Twilight_Tone instanceof Array) {
 if (Time_Manager.Twilight_Tone.length == 4) {
 var value;
 for(var i = 0 ; i < 4 ; i++) {
 value = parseInt(Time_Manager.Twilight_Tone[i], 10);
 if (isNaN(value)) {
 Time_Manager.Twilight_Tone = Time_Manager.Dawn_Tone_Default;
 break;
 }
 Time_Manager.Twilight_Tone[i] = value;
 }
 }
 else
 Time_Manager.Twilight_Tone = Time_Manager.Dawn_Tone_Default;
}
else
 Time_Manager.Twilight_Tone = Time_Manager.Dawn_Tone_Default;

// Ton de l'écran lors de la nuit (Rouge,Vert,Bleu,Saturation)
Time_Manager.Night_Tone_Default = [-68, -68, 0, -68];
Time_Manager.Night_Tone = Time_Manager.Parameters["Ton de l'écran lors de la nuit"].split(",");

if (Time_Manager.Night_Tone instanceof Array) {
 if (Time_Manager.Night_Tone.length == 4) {
 var value;
 for(var i = 0 ; i < 4 ; i++) {
 value = parseInt(Time_Manager.Night_Tone[i], 10);
 if (isNaN(value)) {
 Time_Manager.Night_Tone = Time_Manager.Dawn_Tone_Default;
 break;
 }
 Time_Manager.Night_Tone[i] = value;
 }
 }
 else
 Time_Manager.Night_Tone = Time_Manager.Dawn_Tone_Default;
}
else
 Time_Manager.Night_Tone = Time_Manager.Dawn_Tone_Default;

//==============================================================================
// ? Day&Night_System : DayNight_Timer
//------------------------------------------------------------------------------
// Timer utilisé par le système Day&Night - par Gummy
// Adapté pour RMMV par Palbolsky
// rpgmakervx-fr.com
//==============================================================================
function DayNight_Timer() {
 this.initialize.apply(this, arguments);
}

DayNight_Timer.prototype.initialize = function() {
 this._dawn_count = (Time_Manager.Dawn_Length * 60) * window.FPSMeter.defaults.maxFps;
 this._day_count = (Time_Manager.Day_Length * 60) * window.FPSMeter.defaults.maxFps;
 this._twilight_count = (Time_Manager.Twilight_Length * 60) * window.FPSMeter.defaults.maxFps;
 this._night_count = (Time_Manager.Night_Length * 60) * window.FPSMeter.defaults.maxFps;
 this._count = 0;
 this._working = false;
 this._transition = false;
 // _toPeriod : détermine la transition à effectuer
 // - 1 = De l'aube vers le jour
 // - 2 = Du jour vers le crépuscule
 // - 3 = Du crépuscule vers la nuit
 // - 4 = De la nuit vers l'aube
 this._toPeriod = 0;
 this.start();
}

//--------------------------------------------------------------------------
// ? Boucle de décompte du timer (NE PAS MODIFIER)
//--------------------------------------------------------------------------
DayNight_Timer.prototype.update = function() {
 if ((this._working && this._count) > 0) {
 this._count -= 1;
 if (this._count == 0)
 this.terminate_countdown();
 if (!$dataMap.meta.in && this._transition) {
 switch(this._toPeriod) {
 case 1: // Aube -> Jour
 if ((this._day_count - Time_Manager.Dawn_Transition) > this._count)
 this._transition = false;
 break;
 case 2: // Jour -> Crépuscule
 if ((this._twilight_count - Time_Manager.Day_Transition) > this._count)
 this._transition = false;
 break;
 case 3: // Crépuscule -> Nuit
 if ((this._night_count - Time_Manager.Twilight_Transition) > this._count)
 this._transition = false;
 break;
 case 4: // Nuit -> Aube
 if ((this._dawn_count - Time_Manager.Night_Transition) > this._count)
 this._transition = false;
 break;
 }
 }
 }    
}

//--------------------------------------------------------------------------
// ? Démarrage du timer selon la période de démarrage (jour ou nuit)
//--------------------------------------------------------------------------
DayNight_Timer.prototype.start = function() {
 console.log("Timer start");
 
 if (Time_Manager.StartAtDay) {
 this._count = this._day_count;
 this._toPeriod = 1;
 $gameSwitches[Time_Manager.Switch_ID] = false;
 }
 else {
 this._count = this._night_count;
 this._toPeriod = 3;
 $gameSwitches[Time_Manager.Switch_ID] = true;
 }

 this._working = true;
}

//--------------------------------------------------------------------------
// ? Arrêt du timer
//--------------------------------------------------------------------------
DayNight_Timer.prototype.stop = function() {
 console.log("Timer stop");
 this._working = false;
}

//--------------------------------------------------------------------------
// ? Vérifie si le timer est en train de fonctionner
//--------------------------------------------------------------------------
DayNight_Timer.prototype.isWorking = function() {
 return this._working;
}

//--------------------------------------------------------------------------
// ? Retourne le nombre de secondes restantes
//--------------------------------------------------------------------------
DayNight_Timer.prototype.sec = function() {
 return (this._count / window.FPSMeter.defaults.maxFps);
}

//--------------------------------------------------------------------------
// ? Fonction lors de la fin de la période de la journée, modifie le ton
//  de l'écran, et relance le timer pour la période suivante
//--------------------------------------------------------------------------
DayNight_Timer.prototype.terminate_countdown = function() {
 console.log("Timer arrivé à la fin.");
 this._working = false;

 this._toPeriod += 1;

 if (this._toPeriod == 5)
 this._toPeriod = 1;
 
 switch(this._toPeriod) {
 case 1: // Aube -> Jour
 if (Time_Manager.TimeDetection)
 $gameSwitches[Time_Manager.Switch_ID] = false;
 if (!$dataMap.meta.in)
 $gameScreen.startTint(Time_Manager.Day_Tone, Time_Manager.Dawn_Transition);
 break;
 case 2: // Jour -> Crépuscule
 if (Time_Manager.TimeDetection)
 $gameSwitches[Time_Manager.Switch_ID] = false;
 if (!$dataMap.meta.in)
 $gameScreen.startTint(Time_Manager.Twilight_Tone, Time_Manager.Day_Transition);
 break;
 case 3: // Crépuscule -> Nuit
 if (Time_Manager.TimeDetection)
 $gameSwitches[Time_Manager.Switch_ID] = true;
 if (!$dataMap.meta.in)
 $gameScreen.startTint(Time_Manager.Night_Tone, Time_Manager.Twilight_Transition);
 break;
 case 4: // Nuit -> Aube
 if (Time_Manager.TimeDetection)
 $gameSwitches[Time_Manager.Switch_ID] = true;
 if (!$dataMap.meta.in)
 $gameScreen.startTint(Time_Manager.Dawn_Tone, Time_Manager.Night_Transition);
 break;
 }
 
 this._transition = true;

 this.restart_timer();
}

//--------------------------------------------------------------------------
// ? Relance le timer afin de passer à la phase de la journée suivante.
//--------------------------------------------------------------------------
DayNight_Timer.prototype.restart_timer = function() {
 console.log("Relance du timer...");
 
 switch(this._toPeriod) {
 case 1: // Aube -> Jour
 this._count = this._dawn_count;
 break;
 case 2: // Jour -> Crépuscule
 this._count = this._day_count;
 break;
 case 3: // Crépuscule -> Nuit
 this._count = this._twilight_count;
 break;
 case 4: // Nuit -> Aube
 this._count = this._night_count;
 break;
 }
 
 this._working = true;
}

//--------------------------------------------------------------------------
// ? Définit un ton d'écran sur base de la période actuelle.
//--------------------------------------------------------------------------
DayNight_Timer.prototype.setup_screen_tone = function() {
 if ($dataMap.meta.in)
 $gameScreen.startTint([0, 0, 0, 0], 1);
 
 switch(this._toPeriod) {
 case 1: // Aube -> Jour
 if (Time_Manager.TimeDetection)
 $gameSwitches[Time_Manager.Switch_ID] = false;
 if (!$dataMap.meta.in && !this._transition)
 $gameScreen.startTint(Time_Manager.Day_Tone, 1);
 break;
 case 2: // Jour -> Crépuscule
 if (Time_Manager.TimeDetection)
 $gameSwitches[Time_Manager.Switch_ID] = false;
 if (!$dataMap.meta.in && !this._transition)
 $gameScreen.startTint(Time_Manager.Twilight_Tone, 1);
 break;
 case 3: // Crépuscule -> Nuit
 if (!$dataMap.meta.in && !this._transition)
 $gameScreen.startTint(Time_Manager.Night_Tone, 1);
 break;
 case 4: // Nuit -> Aube
 if (Time_Manager.TimeDetection)
 $gameSwitches[Time_Manager.Switch_ID] = true;
 if (!$dataMap.meta.in && !this._transition)
 $gameScreen.startTint(Time_Manager.Dawn_Tone, 1);
 break;
 }
}

//==============================================================================
// ? Day&Night_System : Redéfinition du module DataManager
//------------------------------------------------------------------------------
// Mémorise l'état du timer pour les sauvegardes/chargements. - par Gummy
// Adapté pour RMMV par Palbolsky
// rpgmakervx-fr.com
//==============================================================================
var _DataManager_makeSaveContents = DataManager.makeSaveContents;
DataManager.makeSaveContents = function() {
 var contents = _DataManager_makeSaveContents.call(this);
 contents.DayNight_System = $Day_Night_Timer;
 return contents;
}

var _DataManager_extractSaveContents = DataManager.extractSaveContents;
DataManager.extractSaveContents = function(contents) {
 _DataManager_extractSaveContents.call(this, contents);
 $Day_Night_Timer = contents.DayNight_System;
}

//==============================================================================
// ? Day&Night_System : Redéfinition de Scene_Map pour lancer le timer
//------------------------------------------------------------------------------
// Ajoute le lancement du timer par Scene_Map, gestion update - par Gummy
// Adapté pour RMMV par Palbolsky
// rpgmakervx-fr.com
//==============================================================================
$Day_Night_Timer = null;

var _Scene_Base_start = Scene_Base.prototype.start;
Scene_Base.prototype.start = function() {
    _Scene_Base_start.call(this);
    if (SceneManager._scene.constructor.name == "Scene_Map" && $Day_Night_Timer == null) {        
        $Day_Night_Timer = new DayNight_Timer();
    }
}

var _Scene_Base_update = Scene_Base.prototype.update;
Scene_Base.prototype.update = function() {
 _Scene_Base_update.call(this);
 if (SceneManager._scene.constructor.name == "Scene_Map")
 $Day_Night_Timer.update();
 
}

var _Scene_Map_start = Scene_Map.prototype.start;
Scene_Map.prototype.start = function() {
 _Scene_Map_start.call(this);
 if ($Day_Night_Timer != null)
 $Day_Night_Timer.setup_screen_tone();
}

var _Scene_Map_onMapLoaded = Scene_Map.prototype.onMapLoaded;
Scene_Map.prototype.onMapLoaded = function() {
 _Scene_Map_onMapLoaded.call(this);
 if ($Day_Night_Timer != null)
 $Day_Night_Timer.setup_screen_tone();
}  

Cet aspect est résolu:

Mist' a écrit:
Sinon, faudra bricoler avec "DayNight_Timer._toPeriod", qui gère les transitions entre les différents moments de la journée, j'ai l'impression.

Code:


this.DayNight_Timer._toPeriod


Code:


Scene_Map.DayNight_Timer._toPeriod


Code:


this.DayNight_Timer._toPeriod=1;


Code:


this.DayNight_Timer.terminate_countdown;


MOG_TimeSystem:

Code:


$gameMap.DayNight_Timer._toPeriod=4;
$gameMap.DayNight_Timer.terminate_countdown;


Code:

$gameMap.DayNight_Timer
this._toPeriod = 4;
this.terminate_countdown;

Code:

$gameMap.DayNight_Timer
this._toPeriod = 4;
this.terminate_countdown;
this.restart_timer;
this.setup_screen_tone;

@Elemsis a écrit:le système de calendrier, jours mois années blabla je l'ai déjà fait en event en fait