[Risata "malvagia" stile anime]

Se leggi su ho già detto che ho preso quella ma volevo vedere se qualcuno aveva qualche alternativa migliore dato che non ho mai detto di volere una risata esattamente uguale a quella del video ma con lo stesso "stile" diciamo

[Sportello aiuti veloci VX-Ace]

Domandina.. Dovrei ottenere questo effetto qui (minuto 7:48):

 

 

Mi riferisco all'evento in basso (la mano che preme il pulsante) non riesco a capire come fare per far si che ad ogni pressione del tasto esegua l'animazione, ho già provato con l'evento in processo parallelo e imput trigger ma non reagisce ad ogni pressione ma "a scatti"... Se non mi sono spiegata bene ditemelo ma spero di essermi fatta capire

[Risata "malvagia" stile anime]

E' quello che ho fatto, ma volevo vedere se qualcuno aveva qualche alternativa migliore xD

[Risata "malvagia" stile anime]

Salve! Cerco un SE di una risata di ragazza su un colpo di scena (Un personaggio buono che si rivela malvagio svelando la sua identita) posto un video per dare un'esempio di come la vorrei

 

https://www.youtube.com/watch?v=tS62wZySmbI

[Sportello aiuti veloci VX-Ace]

Ahh ok ho risolto! Grazie mille Buddy te ne sono molto grata!

[Sportello aiuti veloci VX-Ace]

per 2/3 oggetti con cui interagisce l'eroe, una mappa composta solo da un corridoio che vorrei mantenere sempre zoommata e poi non so, probabilmente lo userò anche per qualche scenetta ma non ho intenzione di utilizzare lo zoom per ogni mappa ma solo per queste cose, come ho già detto, quegli script che hai messo risolvono il problema?

[Sportello aiuti veloci VX-Ace]

Anche zoommando la mappa torna normale

[Sportello aiuti veloci VX-Ace]

ho provato la tua demo BuddyTroller e non mi dà errori nel cambio mappa però appunto lo da in quel modo, comunque il problema è che anche nel mio progetto incasina la mappa ad ogni teletrasporto, e lì non ho generato mappe tramite il generatore di dungeon

 

EDIT: Forse ho capito, l'errore avviene solo se si ci teletrasporta in una mappa delle stesse dimensioni della precedente

 

Si confermato, la mappa si incasina solo in quelle condizioni, il problema adesso è come risolvere la cosa

[Sportello aiuti veloci VX-Ace]

Nono il genera dungeon l'ho usato solo per prova appunto, comunque ho riscaricato la demo ma mi da sempre quell'errore... ho controllato e ho tutto il materiale necessario e la scheda video dovrebbe andare bene... odio quando avvengono questi errori che capitano solo a me :(...

[Sportello aiuti veloci VX-Ace]

Com'è possibile? io prendo esattamente la demo che ho linkato e nel progetto stesso creo un'altra mappa (per essere precisi copio la mappa che c'è già e quindi la incollo e la nuova mappa la modifico facendo "genera dungeon") dopo di chè creo un evento veloce, ovvero la porta e imposto i teletrasporti per passare da una mappa all'altra ed ecco che avviene l'errore... a te non risulta nessun errore? comunque con "pausa" intendevo il menù

[Sportello aiuti veloci VX-Ace]

E' questo il punto, l'errore si verifica anche se non utilizzo lo zoom, per quanto riguarda il cambio mappa utilizzo il classico comando di teletrasporto

[Sportello aiuti veloci VX-Ace]

Pausa* errore di battitura ahahahahaha x'D comunque no non uso altri script.. gli screen che vedi sono fatti nella demo stessa e lì ci sono solo gli script necessari per quell'effetto..

[Sportello aiuti veloci VX-Ace]

Scusate non riesco proprio a risolvere un problema relativo allo script Map_Zoom_Ace_V1.6 relativo al cambio di mappa T_T ecco cosa succede:

 

La mappa in cui mi trovo

 

http://i.imgur.com/G9jkBKl.png

 

Appena cambio mappa

 

http://i.imgur.com/BW227b9.png

 

Quando torno nella mappa di prima

 

http://i.imgur.com/plMyHDw.png

 

La mappa torna normale se metto e tolgo la paura ma non posso fare così ogni volta che cambio mappa... vi prego aiutatemi :( vi allego il download con la demo

http://www.mediafire.com/download/79r7t9v22v5scxt/%5BVXA%5DMap_Zoom_Ace_V1.6.exe

[Sportello aiuti veloci VX-Ace]

 

@Aurora: secondo me stai sbaglando approccio. Lo "script" che hai linkato per primo è una pezza che usa la demo per applicare lo script vero e proprio.

 

 

Se tu stai programmando un evento, utilizza il comando Call Script nel punto desiderato e scrivi: MGC.to_map_zoom(valorezoom, [duratatransizione])

 

EDIT: Faccio una piccola demo, se ti serve.

 

EDIT2: Meanwhile, posto lo stesso una demo dello script, per chi vuole scoprire alcuni piccoli segreti sulla vita di Enom: BUDDY REVELATION

 

 

Grazieee <3 e bellissima la demo xD scusa se rispondo ora ma non ho avuto internet

[Sportello aiuti veloci VX-Ace]

Grazie <3

 

 

EDIT: scusate un'altra cosa sempre riguardante quello script.. in pratica quando cambio mappa mi resta la grafica e il disegno della mappa di prima come se fosse "sovrapposta" sopra e se cambio ulteriormente mappa mi crasha il gioco.. non so se ho reso l'idea comunque vi linko gli script e la demo (perchè anche nella demo se cambio mappa mi dà lo stesso errore)

 

Demo: http://www.rgss-fact...om-de-la-carte/

 

 

#====================================================================
# MGC Tilemap Ace
# v.1.0
# Auteur : MGC
#
# Il s'agit d'une réécriture de la classe Tilemap pour RMVX Ace.
#
# - Ne gère pas le flash_data
# - Ne gère pas le décalage des motifs d'autotiles du tiles du
# tileset A2 avec l'indicateur "counter"
# - Gère le reste, et même d'autres propriétés/méthodes empruntées
# à la classe Sprite :
# - opacity
# - blend_type
# - color
# - tone
# - wave_amp
# - wave_length
# - wave_speed
# - wave_phase
# - zoom
# - flash
# - Ajout d'une méthode to_zoom(new_zoom, duration) pour un zoom
# progressif
#
# Nécessite :
# - le fichier MGC_Map_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 :
# - NEW_TILEMAP_FOR_ALL_MAPS : alimenté à true ou false
# - true : la nouvelle Tilemap sera utilisée pour toutes les cartes
# - false : la nouvelle Tilemap ne sera utilisée que pour les
# cartes dont l'id est dans NEW_TILEMAP_MAPS_IDS
# - NEW_TILEMAP_MAPS_IDS : utilisé si NEW_TILEMAP_FOR_ALL_MAPS est à false
# Contient la liste des id des cartes pour lesquelles la nouvelle
# tilemap doit être utilisée
#====================================================================
module MGC
#--------------------------------------------------------------------------
# * CONFIGURATION
#--------------------------------------------------------------------------
NEW_TILEMAP_FOR_ALL_MAPS = true
NEW_TILEMAP_MAPS_IDS = [1, 2] # seules les cartes 1 et 2 utilisent cette tilemap
#==============================================================================
# ** MGC::Tilemap
#==============================================================================
class Tilemap
#--------------------------------------------------------------------------
# * 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
#--------------------------------------------------------------------------
# * Constantes
#--------------------------------------------------------------------------
RENDER = Win32API.new("MGC_Map_Ace", "renderMap", "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 + 64, Graphics.height + 64)
@sprite_render.bitmap = @render
@sprite_render.x = -32
@sprite_render.y = -32
@sprite_render.z = 0
@sprite_render_layer2 = Sprite.new(viewport)
@render_layer2 = Bitmap.new(Graphics.width + 64, Graphics.height + 64)
@sprite_render_layer2.bitmap = @render_layer2
@sprite_render_layer2.x = -32
@sprite_render_layer2.y = -32
@sprite_render_layer2.z = 200
@zoom_incr = 0.0
@zoom_duration = 0
@parameters = [@render, @render_layer2, map_data, bitmaps,
Cache.picture('autotiles_data'), Cache.picture('autotiles_data_small'),
Cache.picture('autotiles_data_xsmall'), flags, 0, 0, 0, 0, 0, 0, 1024,
100, $game_map.loop_horizontal?, $game_map.loop_vertical?]
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
@refresh_all = true
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
if new_zoom < 0.125 || new_zoom > 8.0 then return end
@zoom = new_zoom
@parameters[14] = (1024.0 / new_zoom).to_i
vox = @ox
@ox = nil
self.ox = vox
voy = @oy
@oy = nil
self.oy = voy
@need_refresh = true
@refresh_all = true
end
end
#--------------------------------------------------------------------------
# * Incrémentation de la valeur du zoom
#--------------------------------------------------------------------------
def incr_zoom(val = 0.02)
@zoom_incr += val
new_zoom = 2 ** @zoom_incr
self.zoom = new_zoom
end
#--------------------------------------------------------------------------
# * Pour aller progressivement vers une nouvelle valeur de zoom
#--------------------------------------------------------------------------
def to_zoom(new_zoom, duration)
unless zoom == new_zoom
if new_zoom < 0.125 || new_zoom > 8.0 then return end
@zoom_duration = duration
target_zoom_incr = Math.log(new_zoom) / Math.log(2)
@zoom_step = (target_zoom_incr - @zoom_incr) / duration
@target_zoom = new_zoom
end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut visible
#--------------------------------------------------------------------------
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
@sprite_render_layer2.visible = flag
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut ox
#--------------------------------------------------------------------------
def ox=(new_ox)
@parameters[12] = 0
unless new_ox == @ox
if ox && $game_map.loop_horizontal?
if (new_ox.to_i - ox >> 5) == $game_map.width - 1 ||
(ox - new_ox.to_i >> 5) == $game_map.width - 1
then
@refresh_all = true
end
end
@ox = new_ox.to_i
ox_zoom = (@ox << 10) / @parameters[14]
ox_floor = ox_zoom >> 5 << 5
unless ox_floor == @parameters[8]
@parameters[12] = ox_floor - @parameters[8] >> 5
@need_refresh = true
end
@parameters[8] = ox_floor
@sprite_render.ox = ox_zoom - ox_floor
@sprite_render_layer2.ox = @sprite_render.ox
end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut oy
#--------------------------------------------------------------------------
def oy=(new_oy)
@parameters[13] = 0
unless new_oy == @oy
if oy && $game_map.loop_vertical?
if (new_oy.to_i - oy >> 5) == $game_map.height - 1 ||
(oy - new_oy.to_i >> 5) == $game_map.height - 1
then
@refresh_all = true
end
end
@oy = new_oy.to_i
oy_zoom = (@oy << 10) / @parameters[14]
oy_floor = oy_zoom >> 5 << 5
unless oy_floor == @parameters[9]
@parameters[13] = oy_floor - @parameters[9] >> 5
@need_refresh = true
end
@parameters[9] = oy_floor
@sprite_render.oy = oy_zoom - oy_floor
@sprite_render_layer2.oy = @sprite_render.oy
end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut opacity
#--------------------------------------------------------------------------
def opacity=(new_opacity)
@opacity = new_opacity
@sprite_render.opacity = new_opacity
@sprite_render_layer2.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
@sprite_render_layer2.blend_type = new_blend_type
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut color
#--------------------------------------------------------------------------
def color=(new_color)
@color = new_color
@sprite_render.color = new_color
@sprite_render_layer2.color = new_color
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut tone
#--------------------------------------------------------------------------
def tone=(new_tone)
@tone = new_tone
@sprite_render.tone = new_tone
@sprite_render_layer2.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
@sprite_render_layer2.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
@sprite_render_layer2.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
@sprite_render_layer2.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
@sprite_render_layer2.wave_phase = new_wave_phase
end
#--------------------------------------------------------------------------
# * Libération de l'instance
#--------------------------------------------------------------------------
def dispose
@render.dispose
@render_layer2.dispose
@sprite_render.dispose
@sprite_render_layer2.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
if @zoom_duration > 0
@zoom_duration -= 1
if @zoom_duration == 0
self.zoom = @target_zoom
else
incr_zoom(@zoom_step)
end
end
if Graphics.frame_count & 31 == 0
@parameters[10] += 1
@parameters[10] %= 3
unless @need_refresh
@need_refresh_anim = true
end
end
if @need_refresh
if @refresh_all
@render.clear
@render_layer2.clear
@parameters[12] = 0
@parameters[13] = 0
@refresh_all = false
end
@parameters[11] = 0
RENDER.call(@parameters.__id__)
@need_refresh = false
elsif @need_refresh_anim
@parameters[11] = 1
@parameters[12] = 0
@parameters[13] = 0
RENDER.call(@parameters.__id__)
@need_refresh_anim = false
end
@sprite_render.update
@sprite_render_layer2.update
end
end
#--------------------------------------------------------------------------
# * Flash des couches de la tilemap
#--------------------------------------------------------------------------
def flash(color, duration)
@sprite_render.flash(color, duration)
@sprite_render_layer2.flash(color, duration)
end
end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_tilemap
alias create_tilemap_mgc_tilemap create_tilemap
@already_aliased_mgc_tilemap = true
end
#--------------------------------------------------------------------------
# * Create Tilemap
#--------------------------------------------------------------------------
def create_tilemap
if MGC::NEW_TILEMAP_FOR_ALL_MAPS ||
MGC::NEW_TILEMAP_MAPS_IDS.include?($game_map.map_id)
then
@tilemap = MGC::Tilemap.new(@viewport1)
@tilemap.map_data = $game_map.data
load_tileset
else
create_tilemap_mgc_tilemap
end
end
end

 

 

 

#====================================================================
# Map Zoom Ace
# v.1.3
# Auteur : MGC
#
# Ce script pour RMVX Ace permet de jouer avec une carte zoomée.
# Le coefficient de zoom peut aller de 1/8 à 8
#
# Nécessite :
# - le script "MGC Tilemap Ace" du même auteur en V.1.0, placé
# directement au-dessus de ce script
#
# Utilisation :
# - pour une carte utilisant la tilemap du script "MGC Tilemap Ace" (cf.
# ce script pour savoir comment obtenir une telle carte), deux
# commandes en script sont utilisables :
# - MGC.map_zoom=(nouvelle valeur de zoom)
# - MGC.to_map_zoom(nouvelle valeur de zoom, durée de la transition)
#
# Configuration :
# - PARALLAX_ZOOM : alimenté à true ou false
# - true : le panorama subi le même zoom que la carte. Désactivé
# par défaut car il semble que cela introduit du lag, et
# je n'ai pas envie de réécrire la gestion du zoom de la
# classe Plane pour remplacer ce que nous a écrit Enterbrain
# - false : le panorama est insensible au zoom de la carte
#====================================================================
module MGC
#--------------------------------------------------------------------------
# * CONFIGURATION
#--------------------------------------------------------------------------
PARALLAX_ZOOM = false
#--------------------------------------------------------------------------
# * GESTION DU ZOOM
#--------------------------------------------------------------------------
@zoom = 1.0
#--------------------------------------------------------------------------
# * Initialisation de la valeur de zoom
#--------------------------------------------------------------------------
def self.initialize_map_zoom
@zoom = $game_system.map_zoom ? $game_system.map_zoom : 1.0
@map_zoom_incr = Math.log(@zoom) / Math.log(2)
@map_zoom_duration = 0
@zoom_map_active = false
end
#--------------------------------------------------------------------------
# * Getter pour l'attribut zoom
#--------------------------------------------------------------------------
def self.map_zoom
return @zoom
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut zoom
#--------------------------------------------------------------------------
def self.map_zoom=(zoom_value)
unless map_zoom == zoom_value
if zoom_value < 0.125 || zoom_value > 8.0 then return end
@zoom = zoom_value
$game_system.map_zoom = @zoom
$game_player.center($game_player.x, $game_player.y)
end
end
#--------------------------------------------------------------------------
# * Incrémentation de la valeur du zoom
#--------------------------------------------------------------------------
def self.incr_map_zoom(val = 0.02)
@map_zoom_incr += val
new_zoom = 2 ** @map_zoom_incr
self.map_zoom = new_zoom
end
#--------------------------------------------------------------------------
# * Pour aller progressivement vers une nouvelle valeur de zoom
#--------------------------------------------------------------------------
def self.to_map_zoom(new_zoom, duration)
unless map_zoom == new_zoom
if new_zoom < 0.125 || new_zoom > 8.0 then return end
@map_zoom_duration = duration
target_zoom_incr = Math.log(new_zoom) / Math.log(2)
@map_zoom_step = (target_zoom_incr - @map_zoom_incr) / duration
@target_map_zoom = new_zoom
end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut zoom_map_active
#--------------------------------------------------------------------------
def self.zoom_map_active=(flag)
@zoom_map_active = flag
end
#--------------------------------------------------------------------------
# * Getter pour l'attribut zoom_map_active
#--------------------------------------------------------------------------
def self.zoom_map_active
return @zoom_map_active
end
#--------------------------------------------------------------------------
# * Mise à jour de la valeur du zoom
#--------------------------------------------------------------------------
def self.update_map_zoom
if @zoom_map_active && @map_zoom_duration > 0
@map_zoom_duration -= 1
if @map_zoom_duration == 0
self.map_zoom = @target_map_zoom
else
self.incr_map_zoom(@map_zoom_step)
end
end
end
end

#==============================================================================
# ** Game_System
#==============================================================================
class Game_System
#--------------------------------------------------------------------------
# * Attributs
#--------------------------------------------------------------------------
attr_accessor :map_zoom
end

#==============================================================================
# ** Viewport
#==============================================================================
class Viewport
#--------------------------------------------------------------------------
# * Attributs
#--------------------------------------------------------------------------
attr_reader :zoom
attr_accessor :contains_zoomable_map
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias initialize_mgc_zoom initialize
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Initialisation
#--------------------------------------------------------------------------
def initialize(*args)
initialize_mgc_zoom(*args)
self.zoom = 1.0
@contains_zoomable_map = false
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut zoom
#--------------------------------------------------------------------------
def zoom=(new_zoom)
unless zoom == new_zoom
if new_zoom < 0.125 || new_zoom > 8.0 then return end
@zoom = new_zoom
end
end
#--------------------------------------------------------------------------
# * Mise à jour du zoom
#--------------------------------------------------------------------------
def update_zoom
if contains_zoomable_map
self.zoom = MGC.map_zoom
end
end
end

#==============================================================================
# ** MGC::Tilemap
#==============================================================================
module MGC
class Tilemap
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias initialize_mgc_zoom initialize
alias update_mgc_zoom update
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Initialisation
#--------------------------------------------------------------------------
def initialize(viewport)
initialize_mgc_zoom(viewport)
@sprite_render.no_viewport_zoom = true
@sprite_render_layer2.no_viewport_zoom = true
viewport.contains_zoomable_map = true
end
#--------------------------------------------------------------------------
# * Mise à jour, appelée normalement à chaque frame
#--------------------------------------------------------------------------
def update
if @visible
self.zoom = viewport.zoom
end
update_mgc_zoom
end
end
end

#==============================================================================
# ** Plane
#==============================================================================
class Plane
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias initialize_mgc_zoom initialize
alias ox_mgc_zoom= ox=
alias oy_mgc_zoom= oy=
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Initialisation
#--------------------------------------------------------------------------
def initialize(*args)
initialize_mgc_zoom(*args)
@phase_viewport_zoom = false
self.ox = 0
self.oy = 0
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut ox
#--------------------------------------------------------------------------
def ox=(new_ox)
unless @phase_viewport_zoom
@base_ox = new_ox
end
self.ox_mgc_zoom = new_ox
end
#--------------------------------------------------------------------------
# * Getter pour l'attribut ox
#--------------------------------------------------------------------------
def ox
return @base_ox
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut oy
#--------------------------------------------------------------------------
def oy=(new_oy)
unless @phase_viewport_zoom
@base_oy = new_oy
end
self.oy_mgc_zoom = new_oy
end
#--------------------------------------------------------------------------
# * Getter pour l'attribut oy
#--------------------------------------------------------------------------
def oy
return @base_oy
end
#--------------------------------------------------------------------------
# * Mise à jour du zoom en fonction du zoom du viewport
#--------------------------------------------------------------------------
def update_viewport_zoom
if MGC::PARALLAX_ZOOM
unless viewport.nil? || !viewport.contains_zoomable_map
@phase_viewport_zoom = true
self.zoom_x = viewport.zoom
self.zoom_y = viewport.zoom
self.ox = - ((Graphics.width >> 1) +
(ox - (Graphics.width >> 1)) * viewport.zoom).to_i
self.oy = - ((Graphics.height >> 1) +
(oy - (Graphics.height >> 1)) * viewport.zoom).to_i
@phase_viewport_zoom = false
end
end
end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias initialize_mgc_zoom initialize
alias create_tilemap_mgc_zoom create_tilemap
alias update_mgc_zoom update
alias update_parallax_mgc_zoom update_parallax
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
MGC.initialize_map_zoom
initialize_mgc_zoom
end
#--------------------------------------------------------------------------
# * Create Tilemap
#--------------------------------------------------------------------------
def create_tilemap
create_tilemap_mgc_zoom
MGC.zoom_map_active = @viewport1.contains_zoomable_map
end
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
def update
MGC.update_map_zoom
update_viewports_zoom
update_mgc_zoom
end
#--------------------------------------------------------------------------
# * Update Parallax
#--------------------------------------------------------------------------
def update_parallax
update_parallax_mgc_zoom
@parallax.update_viewport_zoom
end
#--------------------------------------------------------------------------
# * Update Viewports Zoom
#--------------------------------------------------------------------------
def update_viewports_zoom
@viewport1.update_zoom
end
end

#==============================================================================
# ** Sprite
#==============================================================================
class Sprite
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias initialize_mgc_zoom initialize
alias x_mgc_zoom= x=
alias y_mgc_zoom= y=
alias zoom_x_mgc_zoom= zoom_x=
alias zoom_y_mgc_zoom= zoom_y=
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Attributs
#--------------------------------------------------------------------------
attr_accessor :no_viewport_zoom
#--------------------------------------------------------------------------
# * Initialisation
#--------------------------------------------------------------------------
def initialize(*args)
initialize_mgc_zoom(*args)
@phase_viewport_zoom = false
self.x = 0
self.y = 0
self.zoom_x = 1.0
self.zoom_y = 1.0
self.no_viewport_zoom = false
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut x
#--------------------------------------------------------------------------
def x=(new_x)
unless @phase_viewport_zoom
@base_x = new_x
end
self.x_mgc_zoom = new_x
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut y
#--------------------------------------------------------------------------
def y=(new_y)
unless @phase_viewport_zoom
@base_y = new_y
end
self.y_mgc_zoom = new_y
end
#--------------------------------------------------------------------------
# * Getter pour l'attribut x
#--------------------------------------------------------------------------
def x
return @base_x
end
#--------------------------------------------------------------------------
# * Getter pour l'attribut y
#--------------------------------------------------------------------------
def y
return @base_y
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut zoom_x
#--------------------------------------------------------------------------
def zoom_x=(new_zoom_x)
unless @phase_viewport_zoom
@base_zoom_x = new_zoom_x
end
self.zoom_x_mgc_zoom = new_zoom_x
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut zoom_y
#--------------------------------------------------------------------------
def zoom_y=(new_zoom_y)
unless @phase_viewport_zoom
@base_zoom_y = new_zoom_y
end
self.zoom_y_mgc_zoom = 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_global
return @zoom_x
end
#--------------------------------------------------------------------------
# * Valeur réelle du zoom_y en prenant en compte le zoom de la carte
#--------------------------------------------------------------------------
def zoom_y_global
return @zoom_y
end
end

#==============================================================================
# ** Sprite and all its subclasses
#==============================================================================
[:Sprite, :Sprite_Base, :Sprite_Character, :Sprite_Battler, :Sprite_Picture,
:Sprite_Timer].each {|classname|
parent = eval("#{classname}.superclass")
eval(
"class #{classname} < #{parent}
unless @already_aliased_mgc_zoom_#{classname}
alias update_mgc_zoom_#{classname} update
@already_aliased_mgc_zoom_#{classname} = true
end
def update
update_mgc_zoom_#{classname}
if self.instance_of?(#{classname})
unless viewport.nil? || no_viewport_zoom || !viewport.contains_zoomable_map
@phase_viewport_zoom = true
self.zoom_x = @base_zoom_x * viewport.zoom
self.zoom_y = @base_zoom_y * viewport.zoom
self.x = ((Graphics.width >> 1) +
(x - (Graphics.width >> 1)) * viewport.zoom).to_i
self.y = ((Graphics.height >> 1) +
(y - (Graphics.height >> 1)) * viewport.zoom).to_i
@phase_viewport_zoom = false
end
end
end
end")
}

#==============================================================================
# ** Sprite_Character
#==============================================================================
class Sprite_Character < Sprite_Base
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias update_balloon_mgc_zoom update_balloon
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Update Balloon Icon
#--------------------------------------------------------------------------
def update_balloon
update_balloon_mgc_zoom
if @balloon_sprite then @balloon_sprite.update end
end
end

#==============================================================================
# ** Sprite_Base
#==============================================================================
class Sprite_Base < Sprite
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias animation_set_sprites_mgc_zoom animation_set_sprites
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Set Animation Sprite
# frame : Frame data (RPG::Animation::Frame)
#--------------------------------------------------------------------------
def animation_set_sprites(frame)
animation_set_sprites_mgc_zoom(frame)
@ani_sprites.each {|sprite| sprite.update}
end
end

#==============================================================================
# ** Game_Map
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom
alias set_display_pos_mgc_zoom set_display_pos
alias scroll_down_mgc_zoom scroll_down
alias scroll_left_mgc_zoom scroll_left
alias scroll_right_mgc_zoom scroll_right
alias scroll_up_mgc_zoom scroll_up
@already_aliased_mgc_zoom = true
end
#--------------------------------------------------------------------------
# * Set Display Position
#--------------------------------------------------------------------------
def set_display_pos(x, y)
if MGC.zoom_map_active
if loop_horizontal?
@display_x = (x + width) % width
else
if width * MGC.map_zoom < screen_tile_x
@display_x = (width - screen_tile_x).abs / 2
else
x_min = screen_tile_x * (1.0 / MGC.map_zoom - 1.0) / 2
x_max = width + screen_tile_x * ((1.0 - 1.0 / MGC.map_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 height * MGC.map_zoom < screen_tile_y
@display_y = (height - screen_tile_y).abs / 2
else
y_min = screen_tile_y * (1.0 / MGC.map_zoom - 1.0) / 2
y_max = height + screen_tile_y * ((1.0 - 1.0 / MGC.map_zoom) / 2 - 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_zoom(x, y)
end
end
#--------------------------------------------------------------------------
# * Scroll Down
#--------------------------------------------------------------------------
def scroll_down(distance)
if MGC.zoom_map_active
if loop_vertical?
@display_y += distance
@display_y %= @map.height
@parallax_y += distance if @parallax_loop_y
else
last_y = @display_y
if height * MGC.map_zoom < screen_tile_y
@display_y = (height - screen_tile_y).abs / 2
else
max = height + screen_tile_y * ((1.0 - 1.0 / MGC.map_zoom) / 2 - 1)
@display_y = [@display_y + distance, max].min
end
@parallax_y += @display_y - last_y
end
else
scroll_down_mgc_zoom(distance)
end
end
#--------------------------------------------------------------------------
# * Scroll Left
#--------------------------------------------------------------------------
def scroll_left(distance)
if MGC.zoom_map_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 width * MGC.map_zoom < screen_tile_x
@display_x = (width - screen_tile_x).abs / 2
else
min = screen_tile_x * (1.0 / MGC.map_zoom - 1.0) / 2
@display_x = [@display_x - distance, min].max
end
@parallax_x += @display_x - last_x
end
else
scroll_left_mgc_zoom(distance)
end
end
#--------------------------------------------------------------------------
# * Scroll Right
#--------------------------------------------------------------------------
def scroll_right(distance)
if MGC.zoom_map_active
if loop_horizontal?
@display_x += distance
@display_x %= @map.width
@parallax_x += distance if @parallax_loop_x
else
last_x = @display_x
if width * MGC.map_zoom < screen_tile_x
@display_x = (width - screen_tile_x).abs / 2
else
max = width + screen_tile_x * ((1.0 - 1.0 / MGC.map_zoom) / 2 - 1)
@display_x = [@display_x + distance, max].min
end
@parallax_x += @display_x - last_x
end
else
scroll_right_mgc_zoom(distance)
end
end
#--------------------------------------------------------------------------
# * Scroll Up
#--------------------------------------------------------------------------
def scroll_up(distance)
if MGC.zoom_map_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 height * MGC.map_zoom < screen_tile_y
@display_y = (height - screen_tile_y).abs / 2
else
min = screen_tile_y * (1.0 / MGC.map_zoom - 1.0) / 2
@display_y = [@display_y - distance, min].max
end
@parallax_y += @display_y - last_y
end
else
scroll_up_mgc_zoom(distance)
end
end
end

 

 

il terzo l'ho già linkato nel commento di prima

[Sportello aiuti veloci VX-Ace]

Giusto xD ecco lo script, è solo uno dei 3, ma è quello che mi interessa modificare

 

 

# F5 -> 1:1
# F6 -> 2:1
# F7 -> 4:1
# F8 -> 1:2
module MGC
class << self
#--------------------------------------------------------------------------
# * Aliased methods
#--------------------------------------------------------------------------
unless @already_aliased_mgc_zoom_test
alias update_map_zoom_test update_map_zoom
@already_aliased_mgc_zoom_test = true
end
end
#--------------------------------------------------------------------------
# * Mise à jour de la valeur du zoom
#--------------------------------------------------------------------------
def self.update_map_zoom
if Input.trigger?(:F5)
self.to_map_zoom(1.0, 10)
elsif Input.trigger?(:F6)
self.to_map_zoom(2.0, 10)
elsif Input.trigger?(:F7)
self.to_map_zoom(4.0, 10)
elsif ANIM_SWITCH = 1
self.to_map_zoom(0.5, 10)
end
update_map_zoom_test
end
end

 

[Sportello aiuti veloci VX-Ace]

Vorrei modificare lo script map zoom ace, in questo script c'è scritto che se io premo il tasto f8 si zoomma lo schermo, ma io vorrei poterlo zoomare con uno switch anzichè con un tasto, quindi cosa potrei mettere al posto di "imput.trigger? (:F8)"?

[Sportello aiuti veloci VX-Ace]

Ahh allora no. A meno che modifichi le risorse. Tileset e charset in bianco e nero. Magari qualcuno usa questo script e ti può aiutare=)

 

Speriamo :( comunque grazie lo stesso

 

EDIT: Alla fine ho risolto creando uno sfondo uguale alla mappa che mi interessa, l'ho modificato con paint.net rendendolo in bianco e nero e ho modificato anche i char che mi interessavano, ho optato per la via più lunga ma almeno ha funzionato ahaha

[Sportello aiuti veloci VX-Ace]

Devi fare 0 0 0 255. Provale le cose non ti scoraggiare. Se sbagli, riprovi=)

 

Il problema è che con lo script di khas non me la fa modificare l'opzione :( sto cercando di capire come farlo tramite lo script

[Sportello aiuti veloci VX-Ace]

Eh ma il risultato è uno schermo più scuro non in bianco e nero :(

 

 

EDIT: ho capito qual'è il problema, a causa dello script di khas della luce l'opzione della tinta schermo non funziona, ora provo a vedere se posso farlo tramite lo script

[Sportello aiuti veloci VX-Ace]

Per quello ti basta impostare le tonalità dello schermo in bianco e nero. Per l'effetto visione ti basterà creare un immagine colorandone i bordi e poi sfumarli a tuo piacimento.

 

Intendi questa opzione?

 

http://i.imgur.com/N4I7szI.png

[Sportello aiuti veloci VX-Ace]

@Aurora: strano, sicura che il gioco non laggi o ci siano troppi processi paralleli attivi? ^ ^

non saprei.. ma non credo, ero in una mappa di prova

 

EDIT: scusate vorrei fare un'effetto tipo la visione di un ricordo quindi mi servirebbe avere l'intera mappa compresi i char in bianco e nero, è possibile farlo?

[Sportello aiuti veloci VX-Ace]

@Guardian of Irael: avevo provato a fare un'evento comune in processo parallelo ma l'animazione della corsa non seguiva l'imput del tasto, diciamo che era ritardata..

@AndreyDarko: tu sei una vera e propria risorsa di script ahahaha :P

 

grazie ho risolto <3

[Sportello aiuti veloci VX-Ace]

grazie ragazzi :happy: un'altra cosa.. se volessi fare in modo che ogni volta che corro la grafica del mio personaggio cambia e torna quella di prima non appena smetto di correre come faccio?

[Sportello aiuti veloci VX-Ace]

Salveeeeeee! Domandina: come faccio a far zoommare lo schermo durante il gioco in un determinato punto?

 

tipo da così:

 

http://i.imgur.com/naLhzEY.png

 

 

a così:

 

http://i.imgur.com/Im15kJQ.png