Partagez
Aller en bas
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty [résolu]Je vois rouge

le Lun 22 Oct 2012 - 17:40
Salut j'aimerais vos lumières car j'ai un gros problèmes majeur dont la source et son origine me sont inconnues

Une image parle plus que la grammaire donc voila (attention ça brûle)

Spoiler:
[résolu]Je vois rouge Bug10

[résolu]Je vois rouge 264173

EDIT : Quand je sauvegarde pour fermer et relancer le jeu le bug reste, c'est un event qui ce rebelle ou autre chose ? J'ai besoin de vos lumière là svoupler
Merci d'avance


Dernière édition par Terral le Lun 29 Oct 2012 - 14:11, édité 1 fois
Brandobscure
Brandobscure
Membre

Nombre de messages : 531
Age : 23
Localisation : Belgique
Distinction : aucune
Date d'inscription : 03/01/2011

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Lun 22 Oct 2012 - 18:28
Je ne vois qu'une solution, tu a changé le Ton de l'écran.
Dans un event fait, (modifié le Ton de l'écran)
Ensuite tu a sa :
[résolu]Je vois rouge Iconse10

Tu ne changes rien, tu appuies sur ok, et tu le mets en processus parallèle.
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mar 23 Oct 2012 - 17:42
Super c'est ça merci je vais pouvoir repprendre mon travail Very Happy

Merci encors
Brandobscure
Brandobscure
Membre

Nombre de messages : 531
Age : 23
Localisation : Belgique
Distinction : aucune
Date d'inscription : 03/01/2011

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mar 23 Oct 2012 - 17:47
N'oublie pas de mettre (résolu) dans le titre Very Happy
De rien pour l'aide. ^^
Anonymous
Invité
Invité

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mar 23 Oct 2012 - 19:02
Pour les events qui jouent avec les tons de l'écran, n'hésite pas à incorporer des conditions afin de ne pas être paumé comme tu l'as été là.
Crée un interrupteur "modif_ton_Ok" par exemple, et vérifie sa valeur si tu es à nouveau confronté à ce problème.
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mar 23 Oct 2012 - 19:32
Ok merci ^^

Edit : cale fais toujours et ce de façon aléatoires sur les maps et en fondus (en gros sur une map j'ai rien et la suivante au bout d'un moment ca deviens rouge en fondue)
[résolu]Je vois rouge 436437
Anonymous
Invité
Invité

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 10:42
Regarde du côté de tes événements communs si c'est aléatoire sur n'importe quelle map.
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 10:53
J'ai pas ce genre d'evenement jevien de regarder, cela peut venir d'où alors ? :/
LightNox
LightNox
Membre

Nombre de messages : 1759
Age : 28
Localisation : Chez Moi ^^
Date d'inscription : 10/04/2008

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 10:55
J'ai pas tout lu donc désolé si la solution a déjà était proposé x)

Mais a tu essayer de désinstaller et réinstaller rpg maker ?
Si non, fait le et dit nous le résultat Wink
Anonymous
Invité
Invité

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 10:56
Script ?
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 11:07
J'ai pas tester la solution ultime, la désinstallation et en script j'en aie oui mais je ne pense pas qu'ils puissent changer ainsi les couleurs,

Au cas où je les met ici

SBS de combat
Spoiler:
Code:
#===============================================================================
# Side-View Battle System
# By Jet10985 (Jet)
#===============================================================================
# This script will allow you to have battle where all the actor's sprites are
# display on the right side of the screen.
# This script has: 10 customization options.
#===============================================================================
# Overwritten Methods:
# Scene_Battle: show_attack_animation
# Spriteset_Battle: update_actors
#-------------------------------------------------------------------------------
# Aliased methods:
# Spriteset_Battle: create_actors, create_enemies
# Sprite_Character: initialize, update, dispose, start_new_effect
# Scene_Battle: use_item, next_command, prior_command
# Game_Character: screen_x, screen_y
#===============================================================================

module Jet
  module Sideview
   
    #===========================================================================
    # ENEMY OPTIONS
    #===========================================================================
   
    # These are the attack animations for enemies when they use a regular attack.
    # It follows this format: enemy_id => animation_id
    ENEMY_ATK_ANIMS = {
   
    1 => 4,
    6 => 2,
    5 => 27
   
    }
   
    # This is the default enemy attack animation, used when they do not have a
    # specific attack animation above.
    ENEMY_ATK_ANIMS.default = 1
   
    # This is a list of enemies whose portraits should be flipped in battle.
    FLIPPED_ENEMIES = [2, 3, 4, 5, 8, 10, 12, 13, 14, 16, 17, 18, 19]
   
    #===========================================================================
    # ACTOR OPTIONS
    #===========================================================================
   
    # Should the player sprite have a shadow beneath them?
    PLAYER_SHADOW = true
   
    # These are sprite changes depending on state infliction.
    # It follows this format: state_id => "sprite_appention"
    # This means if the state is inflicted, the sprite will look for a graphic
    # that is the same name as the character's sprite, plus the appended option.
    # EX: Ralph's sprite's name is $ralph. Ralph gets knocked-out. This means
    # state 1 was inflicted, and my below config for 1 was: 1 => "_dead"
    # Now, his shown sprite will be $ralph_dead. If the sprite does not exist,
    # no change will be made.
    # The sprite index will be the same as the actor's.
    STATE_SPRITES = {
   
    1 => "_dead",
    2 => "_poison",
    3 => "_blind"
   
    }
   
    #===========================================================================
    # GENERAL_OPTIONS
    #===========================================================================
   
    # This is the animation displayed when a skill is about to be used.
    SKILL_ANIMATION = 43
   
    # This is the animation displayed when an item is about to be used.
    ITEM_ANIMATION = 43
   
    # These are the animations played when a state is inflicted.
    # It follows this format: state_id => animation_id
    STATE_ANIMATIONS = {
   
    1 => 56,
    2 => 50,
    3 => 51
   
    }
   
    #===========================================================================
    # FIELD OPTIONS
    #===========================================================================
   
    # This is where the line-up begins. [x, y]. The higher the x, the further
    # right and the higher the y the further down.
    FIELD_POS = [400, 220]
   
    # This is how far down, and to the right each player is from the previous
    # actor. [x, y]. Same rules as above.
    FIELD_SPACING = [30, 35]
   
  end
end

#===============================================================================
# DON'T EDIT FURTHER UNLESS YOU KNOW WHAT TO DO.
#===============================================================================

($imported ||= {})[:jet] ||= {}
$imported[:jet][:Sideview] = true

class Game_Character
 
  attr_accessor :step_anime
 
  %w[screen_x screen_y].each {|a|
    aStr = %Q{
      alias jet6372_#{a} #{a}
      def #{a}(*args, &block)
        $BTEST ? 0 : jet6372_#{a}(*args, &block)
      end
    }
    module_eval(aStr)
  }
end

class Game_Actor
 
  def animation_id=(t)
    self.battle_sprite.start_animation($data_animations[t]) rescue nil
  end
end

class Game_Battler
 
  def battle_sprite
    return nil unless SceneManager.scene_is?(Scene_Battle)
    SceneManager.scene.spriteset.battler_sprites.each {|a|
      return a if a.battler == self
    }
    return nil
  end
end

class Spriteset_Battle
 
  alias jet2847_create_enemies create_enemies
  def create_enemies(*args, &block)
    jet2847_create_enemies(*args, &block)
    @enemy_sprites.each {|a|
      a.mirror = Jet::Sideview::FLIPPED_ENEMIES.include?(a.battler.enemy.id)
    }
  end
 
  alias jet3835_create_actors create_actors
  def create_actors(*args, &block)
    jet3835_create_actors(*args, &block)
    @jet_party = $game_party.members
    @actor_sprites.each {|a|
      a.dispose
    }
    @actor_sprites = []
    $game_party.members.each {|a|
      f = Game_Character.new
      f.set_graphic(a.character_name, a.character_index)
      f.step_anime = true
      f.set_direction(4)
      n = Sprite_Character.new(@viewport1, f)
      n.jet_x = Jet::Sideview::FIELD_POS[0] + a.index * Jet::Sideview::FIELD_SPACING[0]
      n.jet_y = Jet::Sideview::FIELD_POS[1] + a.index * Jet::Sideview::FIELD_SPACING[1]
      n.battler = a
      n.battle_sprite = true
      if Jet::Sideview::PLAYER_SHADOW
        v = Sprite.new(nil)
        v.bitmap = Cache.system("Shadow")
        n.shadow_sprite = v
      end
      @actor_sprites.push(n)
    }
  end
 
  def update_actors
    if @jet_party != $game_party.members
      @actor_sprites.each {|a|
        a.dispose
      }
      @actor_sprites = []
      create_actors
    end
    @actor_sprites.each {|a| a.update }
  end
end

class Sprite_Character
 
  attr_accessor :battle_sprite, :jet_x, :jet_y, :shadow_sprite, :battler
 
  alias jet4646_initialize initialize
  def initialize(*args, &block)
    @battle_sprite = false
    jet4646_initialize(*args, &block)
  end
 
  alias jet3645_update update
  def update(*args, &block)
    jet3645_update(*args, &block)
    if @battle_sprite
      @character.step_anime = !@battler.dead?
      @character.update
      self.x = @jet_x
      self.y = @jet_y
      if !@battler.nil?
        f = @battler.states.dup
        f.sort! {|a, b|
          a.priority <=> b.priority
        }.reverse!
        for i in 0...f.size
          a = Jet::Sideview::STATE_SPRITES[f[i].id]
          next if a.nil?
          b = (Cache.character(@character.character_name + a) rescue false)
          next unless b
          index = @character.character_index
          @character.set_graphic(@character.character_name + a, index)
          break
        end
      end
      if !@shadow_sprite.nil?
        @shadow_sprite.x = self.x - @shadow_sprite.width / 2
        @shadow_sprite.y = self.y - 28
        @shadow_sprite.visible = self.visible
        @shadow_sprite.viewport = self.viewport
        @shadow_sprite.z = self.z - 1
      end
    end
  end
 
  alias jet5484_dispose dispose
  def dispose(*args, &block)
    @shadow_sprite.dispose if !@shadow_sprite.nil?
    jet5484_dispose(*args, &block)
  end
 
  def move_x(times, amount)
    i = 0
    until i == times
      self.jet_x += amount
      i += 1
      [Graphics, SceneManager.scene.spriteset].each {|a| a.update }
    end
  end
 
  def effect?
    false
  end
end

class Game_Enemy
 
  def atk_animation_id1
    return Jet::Sideview::ENEMY_ATK_ANIMS[@enemy_id]
  end
 
  def atk_animation_id2
    return 0
  end
end

class Scene_Battle
 
  attr_reader :spriteset
 
  alias jet2711_use_item use_item
  def use_item(*args, &block)
    if @subject.is_a?(Game_Actor)
      if !@subject.current_action.guard?
        @subject.battle_sprite.move_x(11, -6)
      end
    end
    if !@subject.current_action.guard? && !@subject.current_action.attack?
      if @subject.current_action.item.is_a?(RPG::Item)
        n = $data_animations[Jet::Sideview::ITEM_ANIMATION]
      else
        n = $data_animations[Jet::Sideview::SKILL_ANIMATION]
      end
      @subject.battle_sprite.start_animation(n)
      wait_for_animation
    end
    jet2711_use_item(*args, &block)
    if @subject.is_a?(Game_Actor)
      if !@subject.current_action.guard?
        @subject.battle_sprite.move_x(11, 6)
      end
    end
  end
 
  def show_attack_animation(targets)
    aid1 = @subject.atk_animation_id1
    aid2 = @subject.atk_animation_id2
    show_normal_animation(targets, aid1, false)
    show_normal_animation(targets, aid2, true)
  end
 
  %w[next prior].each {|a|
    aStr = %Q{
      alias jet3734_#{a}_command #{a}_command
      def #{a}_command(*args, &block)
        f = BattleManager.actor
        f.battle_sprite.move_x(6, 6) if f.is_a?(Game_Actor)
        jet3734_#{a}_command(*args, &block)
        f = BattleManager.actor
        f.battle_sprite.move_x(6, -6) if f.is_a?(Game_Actor)
      end
    }
    module_eval(aStr)
  }
end

class Game_Action
 
  def guard?
    item == $data_skills[subject.guard_skill_id]
  end
end

if $imported[:jet][:BattlePopUps]
  class Sprite_Character
   
    attr_accessor :popups
       
    alias jet4758_initialize initialize
    def initialize(*args, &block)
      @popups = []
      @updating_sprites = []
      @popup_wait = 0
      jet4758_initialize(*args, &block)
    end
       
    alias jet7467_update update
    def update(*args, &block)
      jet7467_update(*args, &block)
      if @popup_wait == 0
        if !@popups.empty?
          @updating_sprites.push(@popups.pop)
          @popup_wait = 30
        end
      else
        @popup_wait -= 1
      end
      @updating_sprites.each {|a|
        a.visible = true if !a.visible
        a.update
        @updating_sprites.delete(a) if a.disposed?
      }
    end
   
    alias jet5483_dispose dispose
    def dispose(*args, &block)
      (@updating_sprites + @popups).each {|a| a.dispose }
      jet5483_dispose(*args, &block)
    end
   
    alias jet3745_setup_new_effect setup_new_effect
    def setup_new_effect(*args, &block)
      jet3745_setup_new_effect(*args, &block)
      do_sprite_popups
    end
   
    def make_popup(text, color)
      @popups.unshift(Sprite_JetPopup.new(text.to_s, color, self))
    end
   
    def do_sprite_popups
      return if @battler.nil?
      if @battler_struct.nil?
        @battler_struct = Struct.new(:hp, :mp, :tp).new(0, 0, 0)
        @battler_struct.hp = @battler.hp
        @battler_struct.mp = @battler.mp
        @battler_struct.tp = @battler.tp
      end
      check_success_popup
      check_hp_popup
      check_mp_popup
      check_tp_popup
    end
   
    def check_success_popup
      if @battler.result.success
        if @battler.result.critical
          make_popup(Jet::BattlePopUps::CRITICAL_TEXT, Jet::BattlePopUps::CRITICAL_COLOR)
        elsif @battler.result.missed
          make_popup(Jet::BattlePopUps::MISSED_TEXT, Jet::BattlePopUps::MISS_COLOR)
        elsif @battler.result.evaded
          make_popup(Jet::BattlePopUps::EVADED_TEXT, Jet::BattlePopUps::EVADE_COLOR)
        end
        @battler.result.clear_hit_flags
      end
    end
   
    def check_hp_popup
      if @battler_struct.hp != @battler.hp
        f = @battler_struct.hp - @battler.hp
        if f > 0
          make_popup(Jet::BattlePopUps::HURT_TEXT + f.to_s, Jet::BattlePopUps::HURT_COLOR)
        elsif f < 0
          make_popup(Jet::BattlePopUps::HEAL_TEXT + f.abs.to_s, Jet::BattlePopUps::HEAL_COLOR)
        end
        @battler_struct.hp = @battler.hp
      end
    end
   
    def check_mp_popup
      if @battler_struct.mp != @battler.mp
        f = @battler_struct.mp - @battler.mp
        if f > 0
          make_popup(Jet::BattlePopUps::HURT_TEXT_MP + f.to_s, Jet::BattlePopUps::HURT_COLOR_MP)
        elsif f < 0
          make_popup(Jet::BattlePopUps::HEAL_TEXT_MP + f.abs.to_s, Jet::BattlePopUps::HEAL_COLOR_MP)
        end
        @battler_struct.mp = @battler.mp
      end
    end
   
    def check_tp_popup
      if @battler_struct.tp != @battler.tp
        f = (@battler_struct.tp - @battler.tp).round
        if f > 0
          make_popup(Jet::BattlePopUps::HURT_TEXT_TP + f.to_s, Jet::BattlePopUps::HURT_COLOR_TP)
        elsif f < 0
          make_popup(Jet::BattlePopUps::HEAL_TEXT_TP + f.abs.to_s, Jet::BattlePopUps::HEAL_COLOR_TP)
        end
        @battler_struct.tp = @battler.tp
      end
    end
  end
end

système jour/nuit
Spoiler:
Code:
#==============================================================================
# ■ Day&Night_System : Système de gestion du temps d'une journée.
#------------------------------------------------------------------------------
# par Gummy - rpgmakervx-fr.com - v 1.0 - 01/2012
#==============================================================================
# INSTRUCTIONS
# Modifiez les variables suivantes pour personnaliser le système :
#
# - Gestion de la durée des différentes parties de la journée :
#  Dawn_Length, Day_Length, Twilight_Length, Night_Length
#  Dawn_Transition, Day_Transition, Twilight_Transition, Night_Transition
#
# - Gestion du point de démarrage du timer (jour ou nuit) :
#  StartAtDay
#
# - Possibilité qu'un interrupteur soit activé si c'est la nuit :
#  TimeDetection, Switch_ID
#
# Grand merci à Cidiomar et Mist' pour leur aide.
#==============================================================================
# ▼ Day&Night_System : Time_Manager module
#------------------------------------------------------------------------------
# Module de gestion du temps utilisé par le système Day&Night - par Gummy
# rpgmakervx-fr.com
#==============================================================================
module Time_Manager
  # Durée de l'aube en minutes
  Dawn_Length = 1
 
  # Durée du jour en minutes
  Day_Length = 1
 
  # Durée du crépuscule en minutes
  Twilight_Length = 1
 
  # Durée de la nuit en minutes
  Night_Length = 1
 
  # Durée de la transition entre l'aube et le jour en frames (60 frames = 1 sec)
  Dawn_Transition = 300
 
  # Durée de la transition entre le jour et le crépuscule en frames (60 frames = 1 sec)
  Day_Transition = 300
 
  # Durée de la transition entre le crépuscule et la nuit en frames (60 frames = 1 sec)
  Twilight_Transition = 300
 
  # Durée de la transition entre la nuit et l'aube en frames (60 frames = 1 sec)
  Night_Transition = 300
 
  # Démarre le timer en tant que JOUR (en tant que nuit si = false)
  StartAtDay = true
 
  # Gère un interrupteur selon la période (ne gère pas si = false)
  # Utile pour fermer les magasins la nuit, par exemple.
  TimeDetection = true
 
  # Détermine l'interrupteur sur lequel opérer si TimeDetection est à true.
  # Si l'interrupteur est activé, alors c'est la nuit.
  Switch_ID = 1
 
  # Ton de l'écran lors de l'aube (Rouge,Vert,Bleu,Saturation)
  Dawn_Tone = Tone.new(-17,-34,-58,125)
 
  # Ton de l'écran lors du jour (Rouge,Vert,Bleu,Saturation)
  Day_Tone = Tone.new(0,0,0,0)
 
  # Ton de l'écran lors du crépuscule (Rouge,Vert,Bleu,Saturation)
  Twilight_Tone = Tone.new(68,-34,-34,0)
 
  # Ton de l'écran lors de la nuit (Rouge,Vert,Bleu,Saturation)
  Night_Tone = Tone.new(-68,-68,0,-68)
end

#==============================================================================
# ▼ Accesseur sur les données de la map, pour gérer les batiments et l'extérieur
#==============================================================================
class Game_Map
  attr_reader :map
end

#==============================================================================
# ▼ Day&Night_System : DayNight_Timer
#------------------------------------------------------------------------------
# Timer utilisé par le système Day&Night - par Gummy
# rpgmakervx-fr.com
#==============================================================================
class DayNight_Timer
  #--------------------------------------------------------------------------
  # ● Initialisation des paramètres du timer (NE PAS MODIFIER)
  #--------------------------------------------------------------------------
  def initialize
    @dawn_count = (Time_Manager::Dawn_Length * 60) * Graphics.frame_rate
    @day_count = (Time_Manager::Day_Length * 60) * Graphics.frame_rate
    @twilight_count = (Time_Manager::Twilight_Length * 60) * Graphics.frame_rate
    @night_count = (Time_Manager::Night_Length * 60) * Graphics.frame_rate
    @count = 0
    @working = 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
    @toPeriod = 0
    start
  end
 
  #--------------------------------------------------------------------------
  # ● Boucle de décompte du timer (NE PAS MODIFIER)
  #--------------------------------------------------------------------------
  def update   
    if @working && @count > 0
      @count -= 1
      terminate_countdown if @count == 0
    end
  end
 
  #--------------------------------------------------------------------------
  # ● Démarrage du timer selon la période de démarrage (jour ou nuit)
  #--------------------------------------------------------------------------
  def start
    print("Timer start")
   
    if Time_Manager::StartAtDay
      @count = @day_count
      @toPeriod = 1
      $game_switches[Time_Manager::Switch_ID] = false
    else
      @count = @night_count
      @toPeriod = 3
      $game_switches[Time_Manager::Switch_ID] = true
    end
   
    @working = true
  end
 
  #--------------------------------------------------------------------------
  # ● Arrêt du timer
  #--------------------------------------------------------------------------
  def stop
    print("Timer stop")
    @working = false
  end
 
  #--------------------------------------------------------------------------
  # ● Vérifie si le timer est en train de fonctionner
  #--------------------------------------------------------------------------
  def working?
    @working
  end
 
  #--------------------------------------------------------------------------
  # ● Retourne le nombre de secondes restantes
  #--------------------------------------------------------------------------
  def sec
    @count / Graphics.frame_rate
  end
 
  #--------------------------------------------------------------------------
  # ● Détermine l'écran dont modifier le ton
  #--------------------------------------------------------------------------
  def screen
    $game_party.in_battle ? $game_troop.screen : $game_map.screen
  end
 
  #--------------------------------------------------------------------------
  # ● 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
  #--------------------------------------------------------------------------
  def terminate_countdown
    print("\nTimer arrivé à la fin.")
    @working = false
   
    @toPeriod += 1
   
    if @toPeriod == 5
      @toPeriod = 1
    end
   
    case @toPeriod
     
      when 1 # Aube -> Jour
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = false
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Day_Tone, Time_Manager::Dawn_Transition)
        end
       
      when 2 # Jour -> Crépuscule
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = false
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Twilight_Tone, Time_Manager::Day_Transition)
        end
       
      when 3 # Crépuscule -> Nuit
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = true
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Night_Tone, Time_Manager::Twilight_Transition)
        end
       
      when 4 # Nuit -> Aube
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = true
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Dawn_Tone, Time_Manager::Night_Transition)
        end
       
    end
 
    restart_timer 
   
  end
 
  #--------------------------------------------------------------------------
  # ● Relance le timer afin de passer à la phase de la journée suivante.
  #--------------------------------------------------------------------------
  def restart_timer
    print("\nRelance du timer...")
   
    case @toPeriod
      when 1 # Aube -> Jour
        @count = @dawn_count
      when 2 # Jour -> Crépuscule
        @count = @day_count
      when 3 # Crépuscule -> Nuit
        @count = @twilight_count
      when 4 # Nuit -> Aube
        @count = @night_count
    end
   
    @working = true
  end
 
  #--------------------------------------------------------------------------
  # ● Définit un ton d'écran sur base de la période actuelle.
  #--------------------------------------------------------------------------
  def setup_screen_tone
   
    if $game_map.map.note == "IN"
      screen.start_tone_change(Tone.new(0,0,0,0), 1)
    end
     
    case @toPeriod
     
      when 1 # Aube -> Jour
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = false
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Day_Tone, 1)
        end
       
      when 2 # Jour -> Crépuscule
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = false
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Twilight_Tone, 1)
        end
       
      when 3 # Crépuscule -> Nuit
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = true
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Night_Tone, 1)
        end
       
      when 4 # Nuit -> Aube
        if Time_Manager::TimeDetection
          $game_switches[Time_Manager::Switch_ID] = true
        end
        if $game_map.map.note != "IN"
          screen.start_tone_change(Time_Manager::Dawn_Tone, 1)
        end
       
    end
  end
 
end
#==============================================================================
# ▼ Day&Night_System : Redéfinition du module DataManager
#------------------------------------------------------------------------------
# Mémorise l'état du timer pour les sauvegardes/chargements. - par Gummy
# rpgmakervx-fr.com
#==============================================================================
module DataManager
  class << self
    alias :alias_make_save_contents :make_save_contents
    def make_save_contents
      contents = alias_make_save_contents
      contents[:DayNight] = $Day_Night_Timer
      contents
    end
    alias :alias_extract_save_contents :extract_save_contents
    def extract_save_contents(contents)
      alias_extract_save_contents(contents)
      $Day_Night_Timer = contents[:DayNight]
    end
  end
end

#==============================================================================
# ▼ Day&Night_System : Redéfinition de Scene_Map pour lancer le timer
#------------------------------------------------------------------------------
# Ajoute le lancement du timer par Scene_Map, gestion update - par Gummy
# rpgmakervx-fr.com
#==============================================================================
class Scene_Base
  alias :alias_start :start
  def start
    alias_start
    $Day_Night_Timer ||= DayNight_Timer.new unless SceneManager.scene.is_a?(Scene_Title) and SceneManager.scene.is_a?(Scene_Battle)
  end
  alias :alias_update :update
  def update
    alias_update
    $Day_Night_Timer.update unless SceneManager.scene.is_a?(Scene_Title) and SceneManager.scene.is_a?(Scene_Battle)
  end
end

class Scene_Map < Scene_Base
  alias :alias_scene_map_start :start
  def start
    alias_scene_map_start
    $Day_Night_Timer.setup_screen_tone
  end 
  alias :alias_perform_transfer :perform_transfer
  def perform_transfer
    alias_perform_transfer
    $Day_Night_Timer.setup_screen_tone
  end
end

Voila la suite en double post je préviens à l'avance car c'est trop long ^^'


Dernière édition par Terral le Mer 24 Oct 2012 - 11:09, édité 1 fois
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 11:08
La suite maintenant (double-post, désoler, gomenasai, sorry) :
Mode 7
Spoiler:
Code:
#====================================================================
# Mode 7 Ace
# v.1.0
# Auteur : MGC
#
# Il s'agit d'un script de mode 7 basique pour RMVX Ace.
#
# - Permet une inclinaison de la carte de 0° à 89°
# - Toute la carte est inclinée, sans relief. Seuls les évènements
#  paraissent dressés verticalement.
# - L'effet de colorisation à l'horizon est personnalisable.
# - Les tiles animés sont supportés, ainsi que le bouclage de la carte.
# - possibilité de zoomer (de 1:8 à 8:1) quand le mode 7 est activé.
#
# IMPORTANT : SI VOUS RENCONTREZ DU LAG, VEUILLEZ VOUS ASSURER D'AVOIR
# DECOCHER "REDUCE SCREEN FLICKERING" (F1).
#
# Nécessite :
# - le fichier MGC_Mode7_Ace.dll à la racine du projet
# - les 3 fichiers graphiques suivants, déposés dans Pictures/ :
#        - autotiles_data.png
#        - autotiles_data_small.png
#        - autotiles_data_xsmall.png
#
# Configuration :
# - MODE7_MAPS_ID : Contient la liste des id des cartes pour lesquelles
#        le mode 7 est appliqué dès l'entrée sur ces cartes
# - MODE7_DEFAULT_ZOOM : valeur de zoom par défaut qui s'applique dès le
#        passage en mode 7. Compris entre 0.125 et 8.0.
# - MODE7_DEFAULT_ANGLE : valeur d'angle d'inclinaison par défaut qui
#        s'applique dès le passage en mode 7. Compris entre 0 et 89.
# - MODE7_VIEW_LIMIT : nombre de tiles supplémentaires à afficher (en plus
#        des 13 pour la vue normale de la carte en 544 * 416) avant l'horizon.
# - MODE7_FADING_DISTANCE : nombre de tiles avant l'horizon subissant un
#        dégradé de ton et/ou d'opacité.
# - MODE7_FADING_TONE : composantes de couleur R, G, B vers lesquelles tend
#        le dégradé de ton à l'horizon. Chaque composantes peut varier
#        entre -255 et 255.
# - MODE7_FADING_OPACITY : opacité vers laquelle tend le dégradé d'opacité ton
#        à l'horizon. Compris entre 255 (pas de dégradé d'opacité) et 0.
# - MODE7_SCAN_STEP : méthode de rafraîchissement de l'écran :
#        - 1 : l'écran est entièrement redessiné en 1 frame. Déconseillé
#              car extrêmement gourmand en ressources.
#        - 2 : l'écran est redessiné en 2 frames (une ligne de l'écran sur
#              deux est dessinée pour chaque frame).
#        - 3 : l'écran est redessiné en 3 frames (une ligne de l'écran sur
#              trois est dessinée pour chaque frame). Conseillé s'il y a
#              trop de lag.
#
# Utilisation :
# Commandes utilisables comme commandes d'évènement avec Script... :
# - MGC.start_mode7 : lance le mode 7 pour la carte
# - MGC.to_mode7_angle(nouvel angle, durée de transition)
# - MGC.to_mode7_zoom(nouvelle valeur de zoom, durée de transition)
# - MGC.end_mode7 : quitte le mode 7
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * CONFIGURATION
  #--------------------------------------------------------------------------
  MODE7_MAPS_ID = []
  MODE7_DEFAULT_ZOOM = 1.0
  MODE7_DEFAULT_ANGLE = 0
  MODE7_VIEW_LIMIT = 26
  MODE7_FADING_DISTANCE = 13
  MODE7_FADING_TONE = Tone.new(64, 64, 128)
  MODE7_FADING_OPACITY = 0
  MODE7_SCAN_STEP = 3
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  @mode7_zoom = 1.0
  @mode7_active = false
  #--------------------------------------------------------------------------
  # * Lancement du mode 7
  #--------------------------------------------------------------------------
  def self.start_mode7
    @end_mode7 = false
    @spriteset.start_mode7
  end
  #--------------------------------------------------------------------------
  # * Fin du mode 7
  #--------------------------------------------------------------------------
  def self.end_mode7
    @end_mode7 = true
    self.to_mode7_zoom(1.0, 1)
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut spriteset
  #--------------------------------------------------------------------------
  def self.spriteset=(spriteset)
    @spriteset = spriteset
  end
  #--------------------------------------------------------------------------
  # * Initialisation des données du mode 7
  #--------------------------------------------------------------------------
  def self.initialize_mode7
    self.mode7_angle = $game_system.mode7_angle ? $game_system.mode7_angle :
    MODE7_DEFAULT_ANGLE
    @mode7_angle_duration = 0
    @mode7_zoom = $game_system.mode7_zoom ? $game_system.mode7_zoom :
    MODE7_DEFAULT_ZOOM
    @mode7_zoom_incr = Math.log(@mode7_zoom) / Math.log(2)
    @mode7_zoom_duration = 0
    pivot = (Graphics.height >> 1) + 12
    @mode7_data = [pivot, pivot.to_f / Graphics.height, 1.0, 1.0, 0,
    Graphics.height, 0, 0, 0, 0]
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_data
  #--------------------------------------------------------------------------
  def self.mode7_data
    return @mode7_data
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_zoom
  #--------------------------------------------------------------------------
  def self.mode7_zoom
    return @mode7_zoom
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_angle
  #--------------------------------------------------------------------------
  def self.mode7_angle
    return @mode7_angle
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_active
  #--------------------------------------------------------------------------
  def self.mode7_active
    return @mode7_active
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_active
  #--------------------------------------------------------------------------
  def self.mode7_active=(flag)
    $game_system.mode7_active = flag
    @mode7_active = flag
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_zoom
  #--------------------------------------------------------------------------
  def self.mode7_zoom=(zoom_value)
    unless mode7_zoom == zoom_value
      if zoom_value < 0.125 || zoom_value > 8.0 then return end
      @mode7_zoom = zoom_value
      $game_system.mode7_zoom = @mode7_zoom
      $game_player.center($game_player.x, $game_player.y)
    end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur du zoom du mode 7
  #--------------------------------------------------------------------------
  def self.incr_mode7_zoom(val = 0.02)
    @mode7_zoom_incr += val
    new_zoom = 2 ** @mode7_zoom_incr
    self.mode7_zoom = new_zoom
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de zoom du mode 7
  #--------------------------------------------------------------------------
  def self.to_mode7_zoom(new_zoom, duration)
    unless mode7_zoom == new_zoom
      if new_zoom < 0.125 || new_zoom > 8.0 then return end
      @mode7_zoom_duration = duration
      target_zoom_incr = Math.log(new_zoom) / Math.log(2)
      @mode7_zoom_step = (target_zoom_incr - @mode7_zoom_incr) / duration
      @target_mode7_zoom = new_zoom
    end
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_angle
  #--------------------------------------------------------------------------
  def self.mode7_angle=(new_angle)
    unless new_angle == @mode7_angle
      @mode7_angle = [[new_angle, 0].max, 89].min
      @mode7_angle_real = @mode7_angle
      $game_system.mode7_angle = @mode7_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Autre setter pour l'attribut mode7_angle, ne réinitialisant pas @mode7_angle_real
  #--------------------------------------------------------------------------
  def self.set_mode7_angle(new_angle)
    unless new_angle == @mode7_angle
      @mode7_angle = [[new_angle, 0].max, 89].min
      $game_system.mode7_angle = @mode7_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur de l'angle du mode 7
  #--------------------------------------------------------------------------
  def self.incr_mode7_angle(val = 2)
    @mode7_angle_real += @mode7_angle_step
    self.set_mode7_angle(@mode7_angle_real.to_i)
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de l'angle du mode 7
  #--------------------------------------------------------------------------
  def self.to_mode7_angle(new_angle, duration)
    unless @mode7_angle == new_angle
      new_angle = [[new_angle, 0].max, 89].min
      @mode7_angle_duration = duration
      @mode7_angle_step = (new_angle - @mode7_angle).to_f / duration
      @target_mode7_angle = new_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour du mode 7
  #--------------------------------------------------------------------------
  def self.update_mode7
    if @mode7_active
      if @mode7_zoom_duration > 0
        @mode7_zoom_duration -= 1
        if @mode7_zoom_duration == 0
          self.mode7_zoom = @target_mode7_zoom
        else
          self.incr_mode7_zoom(@mode7_zoom_step)
        end
      elsif @mode7_angle_duration > 0
        @mode7_angle_duration -= 1
        if @mode7_angle_duration == 0
          self.mode7_angle = @target_mode7_angle
        else
          self.incr_mode7_angle(@mode7_angle_step)
        end
      elsif @end_mode7
        @spriteset.end_mode7
        @end_mode7 = false
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Vérifie si un effet est en cours
  #--------------------------------------------------------------------------
  def self.effect?
    return @mode7_active && (@mode7_zoom_duration > 0 ||
    @mode7_angle_duration > 0)
  end
  #==============================================================================
  # ** MGC::Tilemap
  #==============================================================================
  class Mode7_Map
    #--------------------------------------------------------------------------
    # * Attributs
    #--------------------------------------------------------------------------
    attr_reader :viewport, :visible, :ox, :oy, :opacity, :blend_type, :color,
    :tone, :wave_amp, :wave_length, :wave_speed, :wave_phase, :zoom, :map_data,
    :flags
    attr_accessor :bitmaps, :flash_data
    attr_reader :alpha, :parameters
    #--------------------------------------------------------------------------
    # * Constantes
    #--------------------------------------------------------------------------
    RENDER = Win32API.new("MGC_Mode7_Ace", "renderMode7", "l", "l")
    #--------------------------------------------------------------------------
    # * Initialisation
    #--------------------------------------------------------------------------
    def initialize(viewport)
      @viewport = viewport
      self.bitmaps = [0, 0, 0, 0, 0, 0, 0, 0, 0]
      @map_data = 0
      @flags = 0
      self.flash_data = nil
      @cx = Graphics.width >> 1
      @cy = Graphics.height >> 1
      @sprite_render = Sprite.new(viewport)
      @render = Bitmap.new(Graphics.width, Graphics.height)
      @sprite_render.bitmap = @render
      @sprite_render.x = 0
      @sprite_render.y = 0
      @sprite_render.z = 0
      @zoom = 1.0
      @view_limit = MODE7_VIEW_LIMIT << 5
      fading_dist = MODE7_FADING_DISTANCE << 5
      fading_begin = Graphics.height + @view_limit - fading_dist
      m7_data = Table.new(Graphics.width + 6, Graphics.height)
      @parameters = [@render, 0, map_data, bitmaps,
      Cache.picture('autotiles_data'), Cache.picture('autotiles_data_small'),
      Cache.picture('autotiles_data_xsmall'), 0, 0, 0, 0, 0, 0, 0, 4096,
      100, $game_map.loop_horizontal?, $game_map.loop_vertical?, MODE7_SCAN_STEP,
      0, m7_data, 2048, 0, MGC.mode7_data[5], MGC.mode7_data[0], 0, 0, 0, 0, 0,
      fading_begin, fading_dist, MODE7_FADING_TONE.red.to_i,
      MODE7_FADING_TONE.green.to_i, MODE7_FADING_TONE.blue.to_i,
      MODE7_FADING_OPACITY]
      MGC.mode7_data[9] = m7_data
      self.alpha = 0
      self.visible = true
      self.zoom = 1.0
      self.ox = 0
      self.oy = 0
      self.opacity = 255
      self.blend_type = 0
      self.color = Color.new
      self.tone = Tone.new
      self.wave_amp = 0
      self.wave_length = 180
      self.wave_speed = 360
      self.wave_phase = 0.0
      @initialization = true
    end
    #--------------------------------------------------------------------------
    # * Refresh all the parameters dependent on the angle of slant
    #--------------------------------------------------------------------------
    def refresh_alpha
      # angle of slant
      alpha_rad = (Math::PI * alpha) / 180
      cos_alpha_real = Math.cos(alpha_rad)
      sin_alpha_real = Math.sin(alpha_rad)
      cos_alpha = (2048 * cos_alpha_real).to_i
      sin_alpha = (2048 * sin_alpha_real).to_i
      distance_h = MGC.mode7_data[5]
      pivot = MGC.mode7_data[0]
      # h0,  z0 : intermediate values used to calculate the slope
      h0 = (-distance_h * pivot * cos_alpha) / ((distance_h << 11) +
      pivot * sin_alpha) + pivot
      z0 = (distance_h << 11).to_f / ((distance_h << 11) + pivot * sin_alpha)
      # slope
      slope_value = (1.0 - z0) / (pivot - h0)
      slope_value_map = (131072 * slope_value).to_i
      corrective_value = 1.0 - pivot * slope_value
      corrective_value_map = (131072 * corrective_value).to_i
      last_line = ((-pivot - @view_limit) * zoom).to_i
      height_limit = (distance_h * last_line * cos_alpha) /
      ((distance_h << 11) - last_line * sin_alpha) + pivot
      height_limit = [height_limit.to_i, 0].max
      parameters[21] = cos_alpha
      parameters[22] = sin_alpha
      parameters[25] = slope_value_map
      parameters[26] = corrective_value_map
      parameters[27] = height_limit
      parameters[29] = MODE7_SCAN_STEP
      MGC.mode7_data[3] = cos_alpha_real
      MGC.mode7_data[4] = sin_alpha_real
      MGC.mode7_data[6] = slope_value
      MGC.mode7_data[7] = corrective_value
      MGC.mode7_data[8] = height_limit   
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut map_data
    #--------------------------------------------------------------------------
    def map_data=(new_map_data)
      @map_data = new_map_data
      parameters[2] = @map_data
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut flags
    #--------------------------------------------------------------------------
    def flags=(new_flags)
      @flags = new_flags
      parameters[7] = @flags
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut zoom
    #--------------------------------------------------------------------------
    def zoom=(new_zoom)
      unless zoom == new_zoom
        @zoom = new_zoom
        parameters[14] = (4096.0 / new_zoom).to_i
        MGC.mode7_data[2] = new_zoom
        vox = @ox
        @ox = nil
        self.ox = vox
        voy = @oy
        @oy = nil
        self.oy = voy
        @need_refresh = true
        parameters[29] = MODE7_SCAN_STEP
        last_line = ((-parameters[24] - @view_limit) * zoom).to_i
        height_limit = (parameters[23] * last_line * parameters[21]) /
        ((parameters[23] << 11) - last_line * parameters[22]) + parameters[24]
        parameters[27] = [height_limit.to_i, 0].max
        MGC.mode7_data[8] = parameters[27]
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut alpha
    #--------------------------------------------------------------------------
    def alpha=(new_alpha)
      unless new_alpha == alpha
        @alpha = new_alpha
        refresh_alpha
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut shadow_opacity
    #--------------------------------------------------------------------------
    def shadow_opacity=(value)
      @parameters[15] = [[value, 0].max, 255].min
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut visible
    #--------------------------------------------------------------------------
    def visible=(flag)
      @visible = flag
      @sprite_render.visible = flag
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut ox
    #--------------------------------------------------------------------------
    def ox=(new_ox)
      new_ox = new_ox.to_i
      unless new_ox == @ox
        @ox = new_ox
        @need_refresh = true
        parameters[8] = @ox
        parameters[29] = MODE7_SCAN_STEP
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut oy
    #--------------------------------------------------------------------------
    def oy=(new_oy)
      new_oy = new_oy.to_i
      unless new_oy == @oy
        @oy = new_oy
        @need_refresh = true
        parameters[9] = @oy
        parameters[29] = MODE7_SCAN_STEP
      end
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut opacity
    #--------------------------------------------------------------------------
    def opacity=(new_opacity)
      @opacity = new_opacity
      @sprite_render.opacity = new_opacity
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut blend_type
    #--------------------------------------------------------------------------
    def blend_type=(new_blend_type)
      @blend_type = new_blend_type
      @sprite_render.blend_type = new_blend_type
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut color
    #--------------------------------------------------------------------------
    def color=(new_color)
      @color = new_color
      @sprite_render.color = new_color
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut tone
    #--------------------------------------------------------------------------
    def tone=(new_tone)
      @tone = new_tone
      @sprite_render.tone = new_tone
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_amp
    #--------------------------------------------------------------------------
    def wave_amp=(new_wave_amp)
      @wave_amp = new_wave_amp
      @sprite_render.wave_amp = new_wave_amp
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_length
    #--------------------------------------------------------------------------
    def wave_length=(new_wave_length)
      @wave_length = new_wave_length
      @sprite_render.wave_length = new_wave_length
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_speed
    #--------------------------------------------------------------------------
    def wave_speed=(new_wave_speed)
      @wave_speed = new_wave_speed
      @sprite_render.wave_speed = new_wave_speed
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut wave_phase
    #--------------------------------------------------------------------------
    def wave_phase=(new_wave_phase)
      @wave_phase = new_wave_phase
      @sprite_render.wave_phase = new_wave_phase
    end
    #--------------------------------------------------------------------------
    # * Libération de l'instance
    #--------------------------------------------------------------------------
    def dispose
      @render.dispose
      @sprite_render.dispose
    end
    #--------------------------------------------------------------------------
    # * Retourne true si l'instance a été libérée
    #--------------------------------------------------------------------------
    def disposed?
      return @render.disposed?
    end
    #--------------------------------------------------------------------------
    # * Mise à jour, appelée normalement à chaque frame
    #--------------------------------------------------------------------------
    def update
      if @visible
        self.alpha = MGC.mode7_angle
        self.zoom = MGC.mode7_zoom
        if Graphics.frame_count & 31 == 0
          parameters[10] += 1
          parameters[10] %= 3
          parameters[29] = MODE7_SCAN_STEP
          unless @need_refresh
            @need_refresh_anim = true
          end
        end
        if parameters[29] > 0 && !@need_refresh && !@need_refresh_anim
          @need_refresh = true
        end
        begin
          if @need_refresh
            parameters[19] += 1
            if parameters[19] == parameters[18]
              parameters[19] = 0
            end
            parameters[11] = 0
            RENDER.call(parameters.__id__)
            parameters[29] -= 1
            if parameters[29] == 0
              @need_refresh = false
            end
          elsif @need_refresh_anim
            parameters[19] += 1
            if parameters[19] == parameters[18]
              parameters[19] = 0
            end
            parameters[11] = 1
            RENDER.call(parameters.__id__)
            parameters[29] -= 1
            if parameters[29] == 0
              @need_refresh_anim = false
            end
          end
          if @initialization && parameters[29] == 0
            @initialization = false
          end
        end while @initialization
        @sprite_render.update
      end
    end
    #--------------------------------------------------------------------------
    # * Flash des couches de la tilemap
    #--------------------------------------------------------------------------
    def flash(color, duration)
      @sprite_render.flash(color, duration)
    end
  end
end

#==============================================================================
# ** Game_System
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_accessor :mode7_zoom, :mode7_angle, :mode7_active
end

#==============================================================================
# ** Game_Map
#==============================================================================
class Game_Map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias set_display_pos_mgc_m7a set_display_pos
    alias scroll_down_mgc_m7a scroll_down
    alias scroll_left_mgc_m7a scroll_left
    alias scroll_right_mgc_m7a scroll_right
    alias scroll_up_mgc_m7a scroll_up
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Set Display Position
  #--------------------------------------------------------------------------
  def set_display_pos(x, y)
    if MGC.mode7_active
      if loop_horizontal?
        @display_x = (x + width) % width
      else
        if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
          @display_x = (width - screen_tile_x) / 2
        else
          x_min = screen_tile_x * (1.0 / MGC.mode7_zoom - 1.0) / 2
          x_max = width + screen_tile_x * ((1.0 - 1.0 / MGC.mode7_zoom) / 2 - 1)
          x = [x_min, [x, x_max].min].max
          @display_x = x
        end
      end
      if loop_vertical?
        @display_y = (y + height) % height
      else
        if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
          @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
        else
          y_min = screen_tile_y * (1.0 / MGC.mode7_zoom - 1.0) * MGC.mode7_data[1]
          y_max = height + screen_tile_y *
          ((1.0 - 1.0 / MGC.mode7_zoom) * (1 - MGC.mode7_data[1]) - 1)
          y = [y_min, [y, y_max].min].max
          @display_y = y
        end
      end
      @parallax_x = x
      @parallax_y = y
    else
      set_display_pos_mgc_m7a(x, y)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Down
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    if MGC.mode7_active
      if loop_vertical?
        @display_y += distance
        @display_y %= @map.height
        @parallax_y += distance if @parallax_loop_y
      else
        last_y = @display_y
        if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
          @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
        else
          max = height + screen_tile_y *
          ((1.0 - 1.0 / MGC.mode7_zoom) * (1 - MGC.mode7_data[1]) - 1)
          @display_y = [@display_y + distance, max].min
        end
        @parallax_y += @display_y - last_y
      end
    else
      scroll_down_mgc_m7a(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Left
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    if MGC.mode7_active
      if loop_horizontal?
        @display_x += @map.width - distance
        @display_x %= @map.width
        @parallax_x -= distance if @parallax_loop_x
      else
        last_x = @display_x
        if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
          @display_x = (width - screen_tile_x) / 2
        else
          min = screen_tile_x * (1.0 / MGC.mode7_zoom - 1.0) / 2
          @display_x = [@display_x - distance, min].max
        end
        @parallax_x += @display_x - last_x
      end
    else
      scroll_left_mgc_m7a(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Right
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    if MGC.mode7_active
      if loop_horizontal?
        @display_x += distance
        @display_x %= @map.width
        @parallax_x += distance if @parallax_loop_x
      else
        last_x = @display_x
        if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
          @display_x = (width - screen_tile_x) / 2
        else
          max = width + screen_tile_x * ((1.0 - 1.0 / MGC.mode7_zoom) / 2 - 1)
          @display_x = [@display_x + distance, max].min
        end
        @parallax_x += @display_x - last_x
      end
    else
      scroll_right_mgc_m7a(distance)
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Up
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    if MGC.mode7_active
      if loop_vertical?
        @display_y += @map.height - distance
        @display_y %= @map.height
        @parallax_y -= distance if @parallax_loop_y
      else
        last_y = @display_y
        if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
          @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
        else
          min = screen_tile_y * (1.0 / MGC.mode7_zoom - 1.0) * MGC.mode7_data[1]
          @display_y = [@display_y - distance, min].max
        end
        @parallax_y += @display_y - last_y
      end
    else
      scroll_up_mgc_m7a(distance)
    end
  end
end

#==============================================================================
# ** Game_CharacterBase
#==============================================================================
class Game_CharacterBase
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :sprite
end

#==============================================================================
# ** Serialisation
#==============================================================================
[:Sprite, :Viewport, :Bitmap, :Font].each {|classname|
  eval(
  "class #{classname}
    def marshal_dump
      return []
    end
    def marshal_load(array)
    end
  end")
}

#==============================================================================
# ** Sprite
#==============================================================================
class Sprite
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias initialize_mgc_m7a initialize
    alias zoom_x_mgc_m7a= zoom_x=
    alias zoom_y_mgc_m7a= zoom_y=
    alias zoom_x_mgc_m7a zoom_x
    alias zoom_y_mgc_m7a zoom_y
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  def initialize(*args)
    initialize_mgc_m7a(*args)
    @phase_mode7 = false
    self.zoom_x = 1.0
    self.zoom_y = 1.0
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x=(new_zoom_x)
    unless @phase_mode7
      @base_zoom_x = new_zoom_x
    end
    self.zoom_x_mgc_m7a = new_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y=(new_zoom_y)
    unless @phase_mode7
      @base_zoom_y = new_zoom_y
    end
    self.zoom_y_mgc_m7a = new_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x
    return @base_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y
    return @base_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_x en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_x_real
    return zoom_x_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_y en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_y_real
    return zoom_y_mgc_m7a
  end
end

#==============================================================================
# ** Sprite_Base
#==============================================================================
class Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias animation_set_sprites_mgc_m7a_aprite_base animation_set_sprites
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Set Animation Sprite
  #    frame : Frame data (RPG::Animation::Frame)
  #--------------------------------------------------------------------------
  def animation_set_sprites(frame)
    if MGC.mode7_active
      cell_data = frame.cell_data
      @ani_sprites.each_with_index do |sprite, i|
        next unless sprite
        pattern = cell_data[i, 0]
        if !pattern || pattern < 0
          sprite.visible = false
          next
        end
        sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
        sprite.visible = true
        sprite.src_rect.set(pattern % 5 * 192,
          pattern % 100 / 5 * 192, 192, 192)
        if @ani_mirror
          sprite.x = @ani_ox - cell_data[i, 1] * zoom_y_real
          sprite.y = @ani_oy + cell_data[i, 2] * zoom_y_real
          sprite.angle = (360 - cell_data[i, 4])
          sprite.mirror = (cell_data[i, 5] == 0)
        else
          sprite.x = @ani_ox + cell_data[i, 1] * zoom_y_real
          sprite.y = @ani_oy + cell_data[i, 2] * zoom_y_real
          sprite.angle = cell_data[i, 4]
          sprite.mirror = (cell_data[i, 5] == 1)
        end
        sprite.z = self.z + 300 + i
        sprite.ox = 96
        sprite.oy = 96
        sprite.zoom_x = cell_data[i, 3] * zoom_y_real / 100.0
        sprite.zoom_y = cell_data[i, 3] * zoom_y_real / 100.0
        sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
        sprite.blend_type = cell_data[i, 7]
      end
    else
      animation_set_sprites_mgc_m7a_aprite_base(frame)
    end
  end
end

#==============================================================================
# ** Sprite_Character
#==============================================================================
class Sprite_Character < Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias initialize_mgc_m7a_aprite_character initialize
    alias update_position_mgc_m7a_aprite_character update_position
    alias update_other_mgc_m7a_aprite_character update_other
    alias update_balloon_mgc_m7a_aprite_character update_balloon
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    character : Game_Character
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil)
    initialize_mgc_m7a_aprite_character(viewport, character)
    character.sprite = self
  end
  #--------------------------------------------------------------------------
  # * Update Position
  #--------------------------------------------------------------------------
  def update_position
    if MGC.mode7_active
      old_x = x
      old_y = y
      update_mode7
      self.z = @character.screen_z
      move_animation(x - old_x, y - old_y)
    else
      update_position_mgc_m7a_aprite_character
    end
  end
  #--------------------------------------------------------------------------
  # * Update Other
  #--------------------------------------------------------------------------
  def update_other
    update_other_mgc_m7a_aprite_character
    if MGC.mode7_active && visible
      if y >= MGC.mode7_data[8] && (y - height * zoom_y_real) < Graphics.height
        self.visible = true
        if y < Graphics.height
          dat = MGC.mode7_data[9]
          self.opacity += dat[5, y]
          self.tone.set(dat[2, y], dat[3, y], dat[4, y])
        end
      else
        self.visible = false
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Position In Mode7
  #--------------------------------------------------------------------------
  def update_mode7
    y_screen = character.screen_y +
    (character.is_a?(Game_Vehicle) ? character.altitude : 0)
    y_init = MGC.mode7_data[2] * (y_screen - MGC.mode7_data[0])
    x_init = MGC.mode7_data[2] * (character.screen_x - (Graphics.width >> 1))
    self.y = (MGC.mode7_data[0] + (MGC.mode7_data[5] * y_init *
    MGC.mode7_data[3]) / (MGC.mode7_data[5] - y_init * MGC.mode7_data[4])).to_i
    zx = MGC.mode7_data[6] * y + MGC.mode7_data[7]
    self.x = ((Graphics.width >> 1) + zx * x_init).to_i
    @phase_mode7 = true
    self.zoom_x = MGC.mode7_data[2] * zx
    self.zoom_y = zoom_x_real
    @phase_mode7 = false
    if character.is_a?(Game_Vehicle)
      self.y -= character.altitude * zoom_y_real
    end
  end
  #--------------------------------------------------------------------------
  # * Update Balloon Icon
  #--------------------------------------------------------------------------
  def update_balloon
    update_balloon_mgc_m7a_aprite_character
    if MGC.mode7_active && @balloon_duration > 0
      @balloon_sprite.y = y - height * zoom_y_real
      @balloon_sprite.zoom_x = zoom_x_real
      @balloon_sprite.zoom_y = zoom_y_real
    end
  end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias initialize_mgc_m7a initialize
    alias create_tilemap_mgc_m7a create_tilemap
    alias update_mgc_m7a update
    alias update_shadow_mgc_m7a update_shadow
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    MGC.spriteset = self
    initialize_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Lance le mode 7
  #--------------------------------------------------------------------------
  def start_mode7
    unless @tilemap_mode7
      MGC.initialize_mode7
      @tilemap_classic = @tilemap
      @tilemap_mode7 = MGC::Mode7_Map.new(@viewport1)
      @tilemap_mode7.map_data = $game_map.data
      @tilemap = @tilemap_mode7
      load_tileset
    end
    @tilemap_mode7.visible = true
    @tilemap_classic.visible = false
    @tilemap = @tilemap_mode7
    MGC.mode7_active = true
  end
  #--------------------------------------------------------------------------
  # * Met fin au mode 7
  #--------------------------------------------------------------------------
  def end_mode7
    @tilemap_mode7.visible = false
    @tilemap_classic.visible = true
    @tilemap = @tilemap_classic
    MGC.mode7_active = false
  end
  #--------------------------------------------------------------------------
  # * Create Tilemap
  #--------------------------------------------------------------------------
  def create_tilemap
    create_tilemap_mgc_m7a
    unless $game_system.mode7_active
      MGC.mode7_active = false
    end
    if MGC::MODE7_MAPS_ID.include?($game_map.map_id) ||
      $game_system.mode7_active
    then
      start_mode7
    end
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    MGC.update_mode7
    update_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Update Airship Shadow Sprite
  #--------------------------------------------------------------------------
  def update_shadow
    if MGC.mode7_active
      airship_sprite = $game_map.airship.sprite
      @shadow_sprite.x = airship_sprite.x
      @shadow_sprite.y = airship_sprite.y + $game_map.airship.altitude *
      airship_sprite.zoom_y_real
      @shadow_sprite.opacity = $game_map.airship.altitude * 8 *
      airship_sprite.opacity
      @shadow_sprite.zoom_x = airship_sprite.zoom_x_real
      @shadow_sprite.zoom_y = airship_sprite.zoom_y_real
      @shadow_sprite.update
    else
      update_shadow_mgc_m7a
    end
  end
end

#==============================================================================
# ** Scene_Map
#==============================================================================
class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
    alias update_call_menu_mgc_m7a update_call_menu
    @already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Determine if Menu is Called due to Cancel Button
  #--------------------------------------------------------------------------
  def update_call_menu
    unless MGC.effect?
      update_call_menu_mgc_m7a
    end
  end
end


La partie 2 du mode 7 ^^"
Spoiler:
Code:
#====================================================================
# Mode 7 Ace Addon : Airship
# v.1.0
# Auteur : MGC
#
# Cet addon pour le script Mode 7 Ace permet le déclenchement du mode 7
# automatiquement dès que le joueur embarque dans le vaisseau.
#
# Nécessite :
# - le script "Mode 7 Ace" du même auteur en V.1.0, placé
#  directement au-dessus de ce script
#====================================================================
#==============================================================================
# ** Game_Player
#==============================================================================
class Game_Player
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a_addon_airship
    alias get_on_vehicle_mgc_m7a_addon_airship get_on_vehicle
    alias get_off_vehicle_mgc_m7a_addon_airship get_off_vehicle
    @already_aliased_mgc_m7a_addon_airship = true
  end
  #--------------------------------------------------------------------------
  # * Board Vehicle
  #    Assumes that the player is not currently in a vehicle.
  #--------------------------------------------------------------------------
  def get_on_vehicle
    get_on_vehicle_mgc_m7a_addon_airship
    if vehicle && @vehicle_type == :airship
      unless MGC.mode7_active
        MGC.start_mode7
      end
      MGC.to_mode7_angle(60, 50)
    end
    return @vehicle_getting_on
  end
  #--------------------------------------------------------------------------
  # * Get Off Vehicle
  #    Assumes that the player is currently riding in a vehicle.
  #--------------------------------------------------------------------------
  def get_off_vehicle
    get_off_vehicle_mgc_m7a_addon_airship
    if MGC.mode7_active
      if @vehicle_getting_off && in_airship?
        MGC.to_mode7_angle(0, 50)
        MGC.end_mode7
      end
    end
    return @vehicle_getting_off
  end
end

Système de temps de jeu et d'or (besoin d'assistance sur ce script au passage*sifflote)
Spoiler:
Code:
###########################################################################
#Afficher l'or, le temps de jeu et la localisation dans le menu#
#By Lightnox(ou dark34590 suivant le forum)#
#permet d'afficher l'or, le temps et la map ou l'on se trouve dans le menu#
#Morceau de code d'origine Blodagan de son script RMVX et Enterbrain#
###########################################################################
class Window_Or_Localisation_Temps_Jeu < Window_Base
  #--------------------------------------------------------------------------
  # Initialize
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 384, 105)
    self.back_opacity = 0
    refresh
  end
  #--------------------------------------------------------------------------
  # Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    aff_or
    aff_temps_de_jeu
  end
  #--------------------------------------------------------------------------
  # Affiche l'or
  #--------------------------------------------------------------------------
  def aff_or
    draw_icon(360, 10, 0)
    draw_icon(360, 10, 0)
    draw_currency_value($game_party.gold, 'Saphire', 70, 0, 120)
  end
  #--------------------------------------------------------------------------
  # Affiche le temps de jeu
  #--------------------------------------------------------------------------
  def aff_temps_de_jeu
    draw_icon(280, 10, 29)
    draw_icon(280, 10, 29)
  end
end
#------------------------------------
class Scene_Menu < Scene_MenuBase
  #--------------------------------------------------------------------------
  # ● Start
  #--------------------------------------------------------------------------
  def start
    super
    create_command_window
    create_or_localisation_temps_jeu_window
    create_status_window
  end
  #--------------------------------------------------------------------------
  # ● Terminate
  #--------------------------------------------------------------------------
  def terminate
    super
  end
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------
  def update
    super
    @or_localisation_temps_jeu_window.refresh
  end
  #--------------------------------------------------------------------------
  # ● Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    @command_window = Window_MenuCommand.new
    @command_window.x = 384
    @command_window.back_opacity = 0
    @command_window.set_handler(:item,      method(:command_item))
    @command_window.set_handler(:skill,    method(:command_personal))
    @command_window.set_handler(:equip,    method(:command_personal))
    @command_window.set_handler(:status,    method(:command_personal))
    @command_window.set_handler(:formation, method(:command_formation))
    @command_window.set_handler(:save,      method(:command_save))
    @command_window.set_handler(:game_end,  method(:command_game_end))
    @command_window.set_handler(:cancel,    method(:return_scene))
  end
  #--------------------------------------------------------------------------
  # ● Create Or Localisation Temps Jeu Window
  #--------------------------------------------------------------------------
  def create_or_localisation_temps_jeu_window
    x = 0
    y = 311
    @or_localisation_temps_jeu_window = Window_Or_Localisation_Temps_Jeu.new(x,y)
  end
  #--------------------------------------------------------------------------
  # ● Create Status Window
  #--------------------------------------------------------------------------
  def create_status_window
    @status_window = Window_MenuStatus.new(0, 0)
    @status_window.back_opacity = 0
  end
end

Script pour enlever le message d'apparition des monstres
Spoiler:
Code:
#==========================================================================
# Supprimer message de début de combat
#==========================================================================
# Par Maxhack
# Pour RMVX le 11 Juillet 2008
# Modifier par Crackerwood le 07/05/2012 pour RMVX ACE
# Insérez au moins le pseudo de Maxhack qui s'en lui je n'aurais pas pu
# modifier ce script.
# Merci !
#==========================================================================

module GameBaker
  BattleEntryEnable = 0
end

class Scene_Battle
  alias gamebaker_battleentry_start battle_start
  def battle_start
    @gb_battleentry = true
    gamebaker_battleentry_start
  end

  alias gamebaker_battleentry_wait wait_for_message
  def wait_for_message
    if @gb_battleentry
      @gb_battleentry = nil
      $game_message.clear if !$game_switches[GameBaker::BattleEntryEnable]
    end
    gamebaker_battleentry_wait
  end
end

Voila bonne lecture ^^'
LightNox
LightNox
Membre

Nombre de messages : 1759
Age : 28
Localisation : Chez Moi ^^
Date d'inscription : 10/04/2008

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 11:27
Non sa ne peut pas venir des scripts a mon avis ^^

essaye d'ouvrir un nouveau projet sans script et teste le pour voir si quand tu est sur la map tu vois encore tout rouge, si c'est le cas sa ne viens pas des scripts.

et la tu testera la solution désagréable ^^ Uninstall et réinstall de rpg maker vx ace x)
Après si sa continue malgrès ça ben..... change de pc xD
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 11:30
NAN TU NE TOUCHE PAS A MON PC !!
*feule*

Ahem... sinon j'ai déjà test avec un nouveau projet, cela ne le fait pas (cela dit les scripts de sont pas mis dans le nouveau projet)

Maintenant que j'y pense, le script de transiton jour/nuit est peut être en cause ?
LightNox
LightNox
Membre

Nombre de messages : 1759
Age : 28
Localisation : Chez Moi ^^
Date d'inscription : 10/04/2008

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 11:39
Ah ouai j'avais pas vue le script jour/nuit ^^
La oui peut être que sa viens de la vue que le ton de l'écran change au fur et a mesure grâce a ce script Smile

Ah tu activer l'interrupteur 0001 en processus parallèle ?
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 11:42
J'ai plusieur evenement en processus parallèle (bin je bricole une cinématique ^^') donc il faut que je modifit un interrupteur dans le script ? Ca s'ras pas du gateau x.x
LightNox
LightNox
Membre

Nombre de messages : 1759
Age : 28
Localisation : Chez Moi ^^
Date d'inscription : 10/04/2008

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 11:56
Code:
  # Détermine l'interrupteur sur lequel opérer si TimeDetection est à true.
  # Si l'interrupteur est activé, alors c'est la nuit.
  Switch_ID = 1

Non ce n'est pas compliquer ^^, dans le script il y a ce morceau de code ci-dessus si tu veut qu'on le ton de l'écran change avec un autre interrupteur c'est facile tu remplace par ceci :


Code:
  # Détermine l'interrupteur sur lequel opérer si TimeDetection est à true.
  # Si l'interrupteur est activé, alors c'est la nuit.
  Switch_ID = 99

Comme ça c'est l'interrupteur N°0099 qui activera le système jour/nuit Wink
après tu modifie la valeur du Switch_ID comme tu veut ^^
et tu active cet interrupteur en processus parallèle et le changement entre chaque ton dure 1 minute.
Donc la réponse et oui ^^ il est normal que tu vois rouge car c'est le script qui fait ça ^^
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Mer 24 Oct 2012 - 14:18
Cool merci bien à toi ^^
Grâce à toi l'aventure repprendra ça marche vers la sortie d'usine Very Happy (attention c'est un produit du terroire ;p)
Elisa'
Elisa'
Staffeux retraité

Nombre de messages : 2924
Age : 21
Localisation : Par là-bas !
Distinction : Mon héritière que je chéris [résolu]Je vois rouge 344805[résolu]Je vois rouge 344805
[Coco' Smile]
Plus que 2 ans avant d'épouser Coco' ! Compte à rebours lancé !
[Auto-distinction]

Adepte du "Je le savais" alors qu'elle le savait pas.
Date d'inscription : 30/05/2009

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Sam 27 Oct 2012 - 22:29
Si ton problème est résolu, indique-le dans le titre du sujet s'il te plaît Smile

_________________


Cliquez ici pour voter pour la commu'
[résolu]Je vois rouge Banner
Terral
Terral
Membre

Nombre de messages : 160
Age : 26
Localisation : Dans la Matrice
Distinction : aucune
Date d'inscription : 15/09/2012

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

le Dim 28 Oct 2012 - 11:27
Oui pardon ^^'
Contenu sponsorisé

[résolu]Je vois rouge Empty Re: [résolu]Je vois rouge

Revenir en haut
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum