UltimaForum :: Zobacz temat

Ayene

~ Rozszerzone okno statusu ~

Krótki opis
Skrypt dodaje w menu rozszerzone okno statusu (patrz screenshot)

Autor skryptu
KGC

Tłumaczenie i przeróbki
Ayene [yurika@o2.pl]

Kompatybilność
Tylko VX.

UWAGA!!!
Do prawidłowego działania wymagane jest umieszczenie w projekcie gry dodatkowego skryptu rozszerzającego możliwości graficzne RPG Makera oraz umieszczenie w folderze z grą biblioteki 'TRGSSX.dll'. Dodatki dostępne są tutaj

Skrypt

Spoiler:

Kod:

# ==========================================================
# ~ Rozszerzone okno statusu ~
# Data publikacji: 11.10.2009
# Autor: KGC
# Tłumaczenie i poprawki: Ayene [yurika@o2.pl]
# Zapraszam na stronę UltimaForum - http://www.ultimateam.pl
# ==========================================================
# Instalacja: Umieść ten skrypt nad Main w Edytorze Skryptu.
# Do poprawnego działania wymagane jest umieszczenie w projekcie gry skryptu
# Bitmapa (by KGC). Skrypt dostępny jest na stronie www.ultimateam.pl
# ==========================================================
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# --------------------------- POCZĄTEK SKRYPTU ---------------------------------
$data_states = load_data("Data/States.rvdata") if $data_states == nil
$data_system = load_data("Data/System.rvdata") if $data_system == nil

module KGC
module ExtendedStatusScene

# ---------------------------- POCZĄTEK EDYCJI ---------------------------------
# Tekst w profilu
PROFILE = []
# W tym miejscu można wpisać tekst, który ma się wyświetlać w profilu.
# Poniższy fragment skryptu należy wypełnić według wzoru:
# PROFILE[ID] = 'Tekst w Profilu'

# Dozwolone jest formatownie tekstu - zmiana koloru (\C[numer]
# Wyświetlanie imienia bohatera - \N[ID]
# Przejście do następnej linijki - \|
PROFILE[1] =
'Name: \N[1]\|' +
'\|' +
'\C[2]Skrypt wyświetla rozszerzony status bohatera\C[0]\|' +
'\|' +
'www.ultimateam.pl'

PROFILE[2] =
'Name: \N[1]\|' +
'\C[2]Wpisz co chcesz\C[0]\|' +
'\|' +
'Tutaj wpisz informacje o bohaterze z ID 1 \|' +
'To jest kolejna linijka tekstu'

COMMANDS = [:param, :element_resist, :state_resist, :profile]

COMMAND_NAME = {
:param => "Statystyki",
:resist => "Odporność",
:element_resist => "Atrybuty",
:state_resist => "Statusy",
:profile => "Profil",
}

PARAMS = [:atk, :def, :spi, :agi, :hit, :eva, :cri, :cp, :ep]

PARAMETER_NAME = {
:hit => "Celność",
:eva => "Unik",
:cri => "Krytyk",
:element_resist => "Atrybuty",
:state_resist => "Statusy",
} # ‹ Nie usuwać tego!

# Styl wyświetlania odporności
# 0 .. Układ graficzny
# 1 .. Wykaz procentowy
# 2 .. Układ graficzny i wykaz procentowy
RESIST_STYLE = 2

# Styl wykazu procentowego
# 0 .. wykazuje procentowo szansę uzyskania przez bohatera konkretnego stanu
# np. jeśli bohater w bazie danych ma ustawioną odporność na status 'śmierć'
# i ma ona wartość A, oznacza to, że bohater ma 100% szansy na jego uzyskanie.

# 1 .. wykazuje procentowo szansę obrony przed konkretnym statusem
# np. jeśli bohater w bazie danych ma ustawioną odporność na status 'śmierć'
# i ma ona wartość A, oznacza to, że bohater ma 0% szansy na obronę przed nim.
RESIST_NUM_STYLE = 1

# Kolor wykresu
CHART_LINE_COLOR = Color.new(128, 255, 128)
CHART_BASE_COLOR = Color.new(128, 192, 255)
CHART_FLASH_COLOR = Color.new(128, 255, 128)

# Jakość wykresu
# true : wysokiej jakości
# false : niskiej jakości
CHART_HIGHQUALITY = true

# Zakres atrybutów/odporności (ID w tablicy)
# od 1 do 16 w bazie danych
ELEMENT_RANGE = [1..16]

# Ikonki atrybutów
# Przyporządkowanie id ikonki do id atrybutu.
ELEMENT_ICON = [0, # ID: 0
50, 1, 4, 14, 24, 12, 189, 136, # ID: 1 ~ 8
104, 105, 106, 107, 108, 109, 110, 111, # ID: 9 ~ 16
] # ‹ Nie usuwać tego!

# Zakres statusów/odporności
# od 1 do tylu ile jest w bazie danych
STATE_RANGE = [1...$data_states.size]
# ----------------------------- KONIEC EDYCJI ----------------------------------
end
end

# -----------NIE EDYTUJ PONIŻEJ, CHYBA ŻE WIESZ CO ROBISZ ^^--------------------
$imported = {} if $imported == nil
$imported["ExtendedStatusScene"] = true

module KGC::ExtendedStatusScene
module_function
#--------------------------------------------------------------------------
# - Konwertowanie zasięgu na liczbę
#--------------------------------------------------------------------------
def convert_integer_array(array, type = nil)
result = []
array.each { |i|
case i
when Range
result |= i.to_a
when Integer
result |= [i]
end
}
case type
when :element
result.delete_if { |x| x >= $data_system.elements.size }
when :state
result.delete_if { |x|
x >= $data_states.size ||
$data_states[x].nonresistance ||
$data_states[x].priority == 0
}
end
return result
end

# Sprawdzanie listy atrybutów
CHECK_ELEMENT_LIST = convert_integer_array(ELEMENT_RANGE, :element)
# Sprawdzanie listy statusów
CHECK_STATE_LIST = convert_integer_array(STATE_RANGE, :state)

# Styl wyświetlania
case RESIST_STYLE
when 0
RESIST_STYLE_SYMBOL = :num
when 1
RESIST_STYLE_SYMBOL = :chart
else
RESIST_STYLE_SYMBOL = :both
end
end

#=========================================================
# Window_StatusCommand
#------------------------------------------------------------------------------
# Dodanie nowych opcji do okna statusu
#=========================================================

class Window_StatusCommand < Window_Command
#--------------------------------------------------------------------------
# - Rozpoczęcie
#--------------------------------------------------------------------------
def initialize
commands = []
KGC::ExtendedStatusScene::COMMANDS.each { |c|
commands << KGC::ExtendedStatusScene::COMMAND_NAME[c]
}
super(160, commands)
self.height = WLH * 5 + 32
self.active = true
end
#--------------------------------------------------------------------------
# - Dodanie nowych komend
#--------------------------------------------------------------------------
def command
return KGC::ExtendedStatusScene::COMMANDS[index]
end
#--------------------------------------------------------------------------
# - Nstępna strona
#--------------------------------------------------------------------------
def cursor_pagedown
return if Input.repeat?(Input::R)
super
end
#--------------------------------------------------------------------------
# - Poprzednia strona
#--------------------------------------------------------------------------
def cursor_pageup
return if Input.repeat?(Input::L)
super
end
end

#=========================================================
# Window_Status
#=========================================================

class Window_Status < Window_Base
#--------------------------------------------------------------------------
# - Rozpoczęcie
#--------------------------------------------------------------------------
def initialize(actor)
super(160, 0, Graphics.width - 160, WLH * 5 + 32)
@actor = actor
refresh
end
#--------------------------------------------------------------------------
# - Odświeżenie
#--------------------------------------------------------------------------
def refresh
self.contents.clear
draw_basic(104, 0)
draw_exp(104, WLH * 3)
end
#--------------------------------------------------------------------------
# - Rysowanie obiektu
#--------------------------------------------------------------------------
def draw_basic(x, y)
draw_actor_face(@actor, 0, (contents.height - 96) / 2)
draw_actor_name(@actor, x, y)
draw_actor_class(@actor, x + 120, y)
draw_actor_level(@actor, x, y + WLH)
draw_actor_state(@actor, x, y + WLH * 2)
draw_actor_hp(@actor, x + 120, y + WLH)
draw_actor_mp(@actor, x + 120, y + WLH * 2)
end
#--------------------------------------------------------------------------
# - Rysowanie punktów doświadczenia
#--------------------------------------------------------------------------
def draw_exp(x, y)
if $imported["GenericGauge"]
draw_actor_exp(@actor, x, y + WLH * 0, 240)
draw_actor_next_exp(@actor, x, y + WLH * 1, 240)
end

s1 = @actor.exp_s
s2 = @actor.next_rest_exp_s
s_next = sprintf(Vocab::ExpNext, Vocab::level)
self.contents.font.color = system_color
self.contents.draw_text(x, y + WLH * 0, 180, WLH, Vocab::ExpTotal)
self.contents.draw_text(x, y + WLH * 1, 180, WLH, s_next)
self.contents.font.color = normal_color

unless $imported["GenericGauge"]
self.contents.draw_text(x, y + WLH * 0, 240, WLH, s1, 2)
self.contents.draw_text(x, y + WLH * 1, 240, WLH, s2, 2)
end
end
end

#=========================================================
# Window_StatusDetail
#------------------------------------------------------------------------------
# Dodanie okna wyświetlającego szczegółowe informacje o bohaterze.
#=========================================================

class Window_StatusDetail < Window_Base
#--------------------------------------------------------------------------
# - Zmienne
#--------------------------------------------------------------------------
attr_reader :category
#--------------------------------------------------------------------------
# - Rozpoczęcie
#--------------------------------------------------------------------------
def initialize(actor)
@category = nil
y = WLH * 5 + 32
super(0, y, Graphics.width, Graphics.height - y)
create_chart_sprite
@actor = actor
@duration = 0
self.z = z
end
#--------------------------------------------------------------------------
# - Tworzenie wykazu
#--------------------------------------------------------------------------
def create_chart_sprite
@element_chart_sprite = Sprite_Base.new
@element_chart_sprite.bitmap = Bitmap.new(height - 32, height - 32)
@element_chart_sprite.ox = @element_chart_sprite.width / 2
@element_chart_sprite.oy = @element_chart_sprite.height / 2
@element_chart_sprite.blend_type = 1
@element_chart_sprite.opacity = 0
@element_chart_sprite.visible = false

@state_chart_sprite = Sprite_Base.new
@state_chart_sprite.bitmap = Bitmap.new(height - 32, height - 32)
@state_chart_sprite.ox = @state_chart_sprite.width / 2
@state_chart_sprite.oy = @state_chart_sprite.height / 2
@state_chart_sprite.blend_type = 1
@state_chart_sprite.opacity = 0
@state_chart_sprite.visible = false
end
#--------------------------------------------------------------------------
# - Zamknięcie
#--------------------------------------------------------------------------
def dispose
@element_chart_sprite.bitmap.dispose
@element_chart_sprite.dispose
@state_chart_sprite.bitmap.dispose
@state_chart_sprite.dispose
super
end
#--------------------------------------------------------------------------
# - Wartość Z
#--------------------------------------------------------------------------
def z=(value)
super(value)
@element_chart_sprite.z = z + 1 if @element_chart_sprite != nil
@state_chart_sprite.z = z + 1 if @state_chart_sprite != nil
end
#--------------------------------------------------------------------------
# - Kategorie
#--------------------------------------------------------------------------
def category=(category)
return if @category == category
@category = category
refresh
end
#--------------------------------------------------------------------------
# - Odświeżanie
#--------------------------------------------------------------------------
def refresh
@element_chart_sprite.visible = false
@state_chart_sprite.visible = false
return if @category == nil

self.contents.clear
case @category
when :param
draw_parameter_list
when :resist
draw_resistance
when :element_resist
draw_element_resistance(0, 0,
KGC::ExtendedStatusScene::RESIST_STYLE_SYMBOL)
when :state_resist
draw_state_resistance(0, 0,
KGC::ExtendedStatusScene::RESIST_STYLE_SYMBOL)
when :profile
draw_profile
end
Graphics.frame_reset
end
#--------------------------------------------------------------------------
# - Tworzenie listy parametrów
#--------------------------------------------------------------------------
def draw_parameter_list
y = 0
KGC::ExtendedStatusScene::PARAMS.each { |param|
draw_parameter(param, 0, y)
y += WLH
}

x = 192
contents.font.color = system_color
contents.draw_text(x, 0, 120, WLH, Vocab::equip)
@actor.equips.each_with_index { |item, i|
draw_item_name(item, x, WLH * (i + 1))
}
contents.font.color = normal_color
end
#--------------------------------------------------------------------------
# - Tworzenie parametrów
#--------------------------------------------------------------------------
def draw_parameter(param, x, y)
case param
when :atk
draw_actor_parameter(@actor, x, y, 0)
when :def
draw_actor_parameter(@actor, x, y, 1)
when :spi
draw_actor_parameter(@actor, x, y, 2)
when :agi
draw_actor_parameter(@actor, x, y, 3)
when :hit
draw_actor_parameter(@actor, x, y, 4)
when :eva
draw_actor_parameter(@actor, x, y, 5)
when :cri
draw_actor_parameter(@actor, x, y, 6)
when :cp
return unless $imported["SkillCPSystem"]
return unless KGC::SkillCPSystem::SHOW_STATUS_CP
draw_actor_cp(@actor, x, y, 156)
when :ep
return unless $imported["EquipExtension"]
return unless KGC::EquipExtension::SHOW_STATUS_EP
draw_actor_ep(@actor, x, y, 156)
end
end
#--------------------------------------------------------------------------
# - Tworzenie parametrów bohatera
#--------------------------------------------------------------------------
def draw_actor_parameter(actor, x, y, type)
return super(actor, x, y, type) if type <= 3

names = KGC::ExtendedStatusScene::PARAMETER_NAME
case type
when 4
parameter_name = names[:hit]
parameter_value = actor.hit
when 5
parameter_name = names[:eva]
parameter_value = actor.eva
when 6
parameter_name = names[:cri]
parameter_value = actor.cri
end
self.contents.font.color = system_color
self.contents.draw_text(x, y, 120, WLH, parameter_name)
self.contents.font.color = normal_color
self.contents.draw_text(x + 120, y, 36, WLH, parameter_value, 2)
end
#--------------------------------------------------------------------------
# - Tworzenie odporności
#--------------------------------------------------------------------------
def draw_resistance
case KGC::ExtendedStatusScene::RESIST_STYLE
when 0
type = :num
else
type = :chart
end

x = 0
contents.font.color = system_color
contents.draw_text(x, 0, 120, WLH,
KGC::ExtendedStatusScene::PARAMETER_NAME[:element_resist])
contents.font.color = normal_color
x = draw_element_resistance(x, WLH, type)

contents.font.color = system_color
contents.draw_text(x, 0, 120, WLH,
KGC::ExtendedStatusScene::PARAMETER_NAME[:state_resist])
x = draw_state_resistance(x, WLH, type)

contents.font.color = normal_color
end
#--------------------------------------------------------------------------
# - Tworzenie odporności na atrybuty
#--------------------------------------------------------------------------
def draw_element_resistance(x, y, type)
if KGC::ExtendedStatusScene::CHART_HIGHQUALITY
Bitmap.smoothing_mode = TRGSSX::SM_ANTIALIAS
end

if [:chart, :both].include?(type) && $imported["BitmapExtension"]
x = draw_element_resistance_chart(x, y)
@element_chart_sprite.visible = true
end
if [:num, :both].include?(type)
x = draw_element_resistance_num(x, y)
end

Bitmap.smoothing_mode = TRGSSX::SM_DEFAULT

return x
end
#--------------------------------------------------------------------------
# - Tworzenie wykresu odporności na atrybuty
#--------------------------------------------------------------------------
def draw_element_resistance_chart(x, y)
r = (contents.height - y - 56) / 2
cx = x + r + 28
cy = y + r + 28
pw = (Bitmap.smoothing_mode == TRGSSX::SM_ANTIALIAS ? 2 : 1)
elements = KGC::ExtendedStatusScene::CHECK_ELEMENT_LIST

draw_chart_line(cx, cy, r, elements.size, 3, pw)

# wykres
points = []
elements.each_with_index { |e, i|
n = @actor.element_rate(e)
n = 100 - n if KGC::ExtendedStatusScene::RESIST_NUM_STYLE == 1
n = [[n, -100].max, 200].min
dr = r * (n + 100) / 100 / 3
rad = Math::PI * (360.0 * i / elements.size - 90.0) / 180.0
dx = cx + Integer(dr * Math.cos(-rad))
dy = cy + Integer(dr * Math.sin(rad))
points << [dx, dy]

dx = cx + Integer((r + 14) * Math.cos(-rad)) - 12
dy = cy + Integer((r + 14) * Math.sin(rad)) - 12
draw_icon(KGC::ExtendedStatusScene::ELEMENT_ICON[e], dx, dy)
}

draw_chart(cx, cy, r, points, pw)
draw_chart_flash(@element_chart_sprite, x, y, r, points, pw)

return (x + cx + r + 42)
end
#--------------------------------------------------------------------------
# - Tworzenie wykazu procentowego odporności na atrybuty
#--------------------------------------------------------------------------
def draw_element_resistance_num(x, y)
origin_y = y
contents.font.color = normal_color
KGC::ExtendedStatusScene::CHECK_ELEMENT_LIST.each { |i|
if y + WLH > contents.height
x += 84
y = origin_y
end
draw_icon(KGC::ExtendedStatusScene::ELEMENT_ICON[i], x, y)
n = @actor.element_rate(i)
n = 100 - n if KGC::ExtendedStatusScene::RESIST_NUM_STYLE == 1
rate = sprintf("%4d%%", n)
contents.draw_text(x + 24, y, 52, WLH, rate, 2)
y += WLH
}
return (x + 96)
end
#--------------------------------------------------------------------------
# - Tworzenie odporności na statusy
#--------------------------------------------------------------------------
def draw_state_resistance(x, y, type)
if KGC::ExtendedStatusScene::CHART_HIGHQUALITY
Bitmap.smoothing_mode = TRGSSX::SM_ANTIALIAS
end

if [:chart, :both].include?(type) && $imported["BitmapExtension"]
x = draw_state_resistance_chart(x, y)
@state_chart_sprite.visible = true
end
if [:num, :both].include?(type)
x = draw_state_resistance_num(x, y)
end

Bitmap.smoothing_mode = TRGSSX::SM_DEFAULT

return x
end
#--------------------------------------------------------------------------
# - Tworzenie wykresu odporności na statusy
#--------------------------------------------------------------------------
def draw_state_resistance_chart(x, y)
r = (contents.height - y - 56) / 2
cx = x + r + 28
cy = y + r + 28
pw = (Bitmap.smoothing_mode == TRGSSX::SM_ANTIALIAS ? 2 : 1)
states = KGC::ExtendedStatusScene::CHECK_STATE_LIST

draw_chart_line(cx, cy, r, states.size, 2, pw)

# wykres
points = []
states.each_with_index { |s, i|
state = $data_states[s]
n = @actor.state_probability(s)
n = 100 - n if KGC::ExtendedStatusScene::RESIST_NUM_STYLE == 1
dr = r * n / 100
rad = Math::PI * (360.0 * i / states.size - 90.0) / 180.0
dx = cx + Integer(dr * Math.cos(-rad))
dy = cy + Integer(dr * Math.sin(rad))
points << [dx, dy]

dx = cx + Integer((r + 14) * Math.cos(-rad)) - 12
dy = cy + Integer((r + 14) * Math.sin(rad)) - 12
draw_icon(state.icon_index, dx, dy)
}

draw_chart(cx, cy, r, points, pw)
draw_chart_flash(@state_chart_sprite, x, y, r, points, pw)

return (x + cx + r + 42)
end
#--------------------------------------------------------------------------
# - Tworzenie wykazu procentowego odporności na statusy
#--------------------------------------------------------------------------
def draw_state_resistance_num(x, y)
origin_y = y
contents.font.color = normal_color
KGC::ExtendedStatusScene::CHECK_STATE_LIST.each { |i|
state = $data_states[i]
if y + WLH > contents.height
x += 76
y = origin_y
end
draw_icon(state.icon_index, x, y)
n = @actor.state_probability(i)
n = 100 - n if KGC::ExtendedStatusScene::RESIST_NUM_STYLE == 1
rate = sprintf("%3d%%", n)
contents.draw_text(x + 24, y, 44, WLH, rate, 2)
y += WLH
}
return x
end
#--------------------------------------------------------------------------
# - Rysowanie wykazu graficznego - linie
#--------------------------------------------------------------------------
def draw_chart_line(cx, cy, r, n, breaks, pw)
color = KGC::ExtendedStatusScene::CHART_BASE_COLOR.clone
contents.draw_regular_polygon(cx, cy, r, n, color, pw)
color.alpha = color.alpha * 5 / 8
contents.draw_spoke(cx, cy, r, n, color, pw)
(1..breaks).each { |i|
contents.draw_regular_polygon(cx, cy, r * i / breaks, n, color, pw)
}
end
#--------------------------------------------------------------------------
# - Tworzenie wykresu
#--------------------------------------------------------------------------
def draw_chart(cx, cy, r, points, pw)
contents.draw_polygon(points, KGC::ExtendedStatusScene::CHART_LINE_COLOR, 2)
end
#--------------------------------------------------------------------------
# - Tworzenie efektu błysku w wykresie
#--------------------------------------------------------------------------
def draw_chart_flash(sprite, x, y, r, points, pw)
points = points.clone
points.each { |pt| pt[0] -= x }

cx = x + r + 28
cy = y + r + 28
color = KGC::ExtendedStatusScene::CHART_FLASH_COLOR
sprite.bitmap.clear
sprite.bitmap.fill_polygon(points, Color.new(0, 0, 0, 0), color)
sprite.ox = cx - x
sprite.oy = cy
sprite.x = self.x + cx + 16
sprite.y = self.y + cy + 16
end
#--------------------------------------------------------------------------
# - Tworzenie profilu
#--------------------------------------------------------------------------
def draw_profile
profile = KGC::ExtendedStatusScene::PROFILE[@actor.id]
return if profile == nil

self.contents.font.color = normal_color
profile.split(/\\\|/).each_with_index { |line, i|
draw_profile_text(0, WLH * i, line)
}
end
#--------------------------------------------------------------------------
# - Tworzenie tekstu w profilu
#--------------------------------------------------------------------------
def draw_profile_text(x, y, text)
buf = convert_special_characters(text)
while (c = buf.slice!(/./m)) != nil
case c
when "\x01"
buf.sub!(/\[(\d+)\]/, "")
contents.font.color = text_color($1.to_i)
next
when "\x02"
n = $game_party.gold.to_s
cw = contents.text_size(n).width
contents.draw_text(x, y, cw + 8, WLH, n)
x += cw
else
contents.draw_text(x, y, 40, WLH, c)
x += contents.text_size(c).width
end
end
contents.font.color = normal_color
end
#--------------------------------------------------------------------------
# - Konwertowanie znaków specjalnych
#--------------------------------------------------------------------------
def convert_special_characters(text)
buf = text.dup
buf.gsub!(/\\V\[(\d+)\]/i) { $game_variables[$1.to_i] }
buf.gsub!(/\\V\[(\d+)\]/i) { $game_variables[$1.to_i] }
buf.gsub!(/\\N\[(\d+)\]/i) { $game_actors[$1.to_i].name }
buf.gsub!(/\\C\[(\d+)\]/i) { "\x01[#{$1}]" }
buf.gsub!(/\\G/) { "\x02" }
buf.gsub!(/\\\\/) { "\\" }
return buf
end
#--------------------------------------------------------------------------
# - Odświeżanie
#--------------------------------------------------------------------------
def update
super
update_chart
end
#--------------------------------------------------------------------------
# - Aktualizacja wykazu
#--------------------------------------------------------------------------
def update_chart
return if @element_chart_sprite == nil

@element_chart_sprite.update
@state_chart_sprite.update

zoom = opacity = 0
case @duration
when 0..11
zoom = @duration / 11.0
opacity = 255
when 12..27
zoom = 1
opacity = (27 - @duration) * 16
end
@element_chart_sprite.zoom_x = @element_chart_sprite.zoom_y = zoom
@element_chart_sprite.opacity = opacity
@state_chart_sprite.zoom_x = @state_chart_sprite.zoom_y = zoom
@state_chart_sprite.opacity = opacity

@duration = (@duration + 1) % Graphics.frame_rate
end
end

#=========================================================
# Scene_Status
#=========================================================

class Scene_Status < Scene_Base
#--------------------------------------------------------------------------
# - Rozpoczęcie
#--------------------------------------------------------------------------
def initialize(actor_index = 0, command_index = 0)
@actor_index = actor_index
@command_index = command_index
end
#--------------------------------------------------------------------------
# - Start
#--------------------------------------------------------------------------
alias start_KGC_ExtendedStatusScene start
def start
start_KGC_ExtendedStatusScene

@command_window = Window_StatusCommand.new
@command_window.index = @command_index
@detail_window = Window_StatusDetail.new(@actor)
@detail_window.category = @command_window.command
end
#--------------------------------------------------------------------------
# - Zakończenie
#--------------------------------------------------------------------------
alias terminate_KGC_ExtendedStatusScene terminate
def terminate
terminate_KGC_ExtendedStatusScene

@command_window.dispose
@detail_window.dispose
end
#--------------------------------------------------------------------------
# - Następny bohater
#--------------------------------------------------------------------------
def next_actor
@actor_index += 1
@actor_index %= $game_party.members.size
$scene = Scene_Status.new(@actor_index, @command_window.index)
end
#--------------------------------------------------------------------------
# - Poprzedni bohater
#--------------------------------------------------------------------------
def prev_actor
@actor_index += $game_party.members.size - 1
@actor_index %= $game_party.members.size
$scene = Scene_Status.new(@actor_index, @command_window.index)
end
#--------------------------------------------------------------------------
# - Odświeżanie
#--------------------------------------------------------------------------
alias update_KGC_ExtendedStatusScene update
def update
@command_window.update
@detail_window.update
@detail_window.category = @command_window.command

update_KGC_ExtendedStatusScene
end
end

Demo
brak

Screenshot

Instrukcja
1. Wklej skrypt nad "Main" w Edytorze Skryptu.
2. Dalsza konfiguracja wyjaśniona w skrypcie.

rozszerzony_status.txt
Jeśli korzystasz z IE:
Prawy przycisk myszy i 'Zapisz element docelowy jako...'

Pobierz Plik ściągnięto 507 raz(y) 27,77 KB

dawidos989

Nie wiem jak to dodać pobrałem to ale nic z tego pobranego nie rocumie

[ Dodano: Pią 06 Lis, 2009 16:57 ]
mogła byś dodać tom skrypt normalnie a nie w pobieraniu ?

[ Dodano: Pią 06 Lis, 2009 18:14 ]
prosze powiedz mi jak zrobić tego skrypta

Sarc · Preferowany: Dołączył: 09 Lis 2009 Posty: 13

Dziękuje za taki skrypt:

????? 'Status' ? 526 ??? NameError ???????? uninitialized constant Window_StatusDetail::TRGSSX

Ayene

A czytałeś insurekcję? Przeczytaj u góry UWAGA!!!

Sarc · Preferowany: Dołączył: 09 Lis 2009 Posty: 13

Acha, sorry za problemy.

krychapl · Preferowany: Dołączył: 05 Sty 2010 Posty: 38

Mam problem wgrałem bitmapę i tą bibliotekę która jest potrzebna i wyświetla mi się taki błąd:

Ayene

W takim razie, zajrzyj do dema (w załączniku). Wrzuciłam tam wszystko, co trzeba.

Nowy Status.rar
Pobierz DEMO

Pobierz Plik ściągnięto 402 raz(y) 306,72 KB

krychapl · Preferowany: Dołączył: 05 Sty 2010 Posty: 38

Znalazłem problem. Ten skrypt nie działa z skryptem rozszerzenia ekwipunku http://www.ultimateam.pl/viewtopic.php?t=2171 . Gdy nie ma rozszerzenia ekwipunku wszystko działa a jak wgram rozszerzenie ekwipunku już nie działa. Da radę zrobić żeby one oba razem działały?

Ayene

W skrypcie 'Rozszerzone okno statusu' znajdź i usuń fragment (linijka 393):

Kod:

when :ep
return unless $imported["EquipExtension"]
return unless KGC::EquipExtension::SHOW_STATUS_EP
draw_actor_ep(@actor, x, y, 156)

Melvin

Skrypt fajny, ale po co "TRGSSX.dll"?
I czy jest taki do XP?

Hemp Gru

Mam błąd!
Co zrobić, aby zamiast profil tam pisało bohater, i zamiast atrybuty to umiejętności? Bo jak zmieniam w skrypcie to zaraz po otworzeniu projektu wyskakuje to:

Ayene

Edytuj w skrypcie linijkę:

Kod:

COMMAND_NAME = {
:param => "Statystyki",
:resist => "Odporność",
:element_resist => "Atrybuty",
:state_resist => "Statusy",
:profile => "Profil",
}

Lord Khartos

Mam podobny problem co kryhapl tylko u mnie jest gdy naprowadzam na statusy i atrybuty

Na Statusach:
-Z linijką 525 czyli Bitmap.smoothing_mode = TRGSSX::SM_ANTIALIAS

Na Atrybutach:
-Z linijką 451 czyli Bitmap.smoothing_mode = TRGSSX::SM_ANTIALIAS

przy czym jak widać te dwie linijki są takie same.

Ayene

Lord Khartos, tzn. jaki problem? Skrypt Tobie nie działa?

Lord Khartos

Skrypt niby działa ale tak się dzieje gdy naprowadzam na karty Statusu i Atrybutów.