Messages

Of corse I didn't make it, I even list whole credits in a text file.
Here is the list:

Enu, Atoa
game_guy
fukuyama
MGCaladtogel
Ccoa
Blizzard
Law
LiTTleDRAgo

Now see? (And stop calling me mattfriend or whatever, I'm getting sick of it. WHO THE HELL IS THAT?)

Oh yeah ~ ~ ~
I will be making one!

Looks familiar...
Is that your card?

Yep, with some modifyings.
So I'm asking here what I should add.

Thanks a lot everyone
Im at school right now, but as soon as i arrive home I will practise it a bit...

Another question...u said that it will make my document an array right?
How does it works in this case?
line[0] = #information on first line
line = #information on i line


like that?

It splits into array.
Example, this is your text document:
+-------------------------------+
| Dear Blah,                              |
| How are you doin?                   |
| If you received my msg just call |
| me back, ok?                          |
|                                             |
| Love,                                    |
| Awesome Face                        |
+-------------------------------+

line[0] = Dear Blah,
line[1] = How are you doin?
line[2] = If you received my msg just call
line[3] = me back, ok?
line[4] =
line[5] = Love,
line[6] = Awesome Face

I will upload the video and you guys will see.
EDITED: Here is the video, http://www.youtube.com/watch?v=OhATgunhFtU .

in case your wondering to convert a string into a function call first convert it to a symbol then send a message to the object with the function

look into the .call method to learn more. in the ruby-docs it should be under object

Can you actually link me the page or an example? There are so many calls.

my bad, now it's fixed

@storm : that edit still wrong, but thanks anyway

Sorry, I was only replaced a word by searching a keyword.
I didn't tested it either.

I used to do it as well. But then I just switched to \n. xD

I used to say "\n" is the basic of string. XD

This is the battle system I have right now. I will be uploading the video later.

Spoiler: ShowHide

I need a suggestion, what do you think the good battle system should have?
Video: http://www.youtube.com/watch?v=OhATgunhFtU

[require]

Look into actual Ruby. That is how it is done with that, simply reading .rb files.
If you simply want to execute a whole file, or load it into memory, save a text document with an .rb extension and use:

require "TEXT_DOC_NAME"

If you want to use an external text file and execute code off of it, something like this should work:

lines = IO.readlines('TEXT_DOC_NAME.txt')
# You can use the ".join" method to combine the lines into a single string, otherwise it will be an array of lines
eval(lines[LINE_INDEX_TO_EXECUTE]) 

If you want to create an instance of the file:

file = File.open('TEXT_DOC_NAME.txt', 'rb') 
# Do something
file.close

To write text to the doc:

file = File.open('TEXT_DOC_NAME.txt', 'wb')
file.write("This is a string")
file.write("\r\nThis is on the second line\r\n")
file.write("\tThis is the third line, and indented")
file.close

EDIT:
And "yes", you can convert strings into functions. I even came up with ways to construct and add new methods to instances of classes at runtime.

OH!!! Thanks Zer0! I totally forgot of the require method! I focused too much about the script so I forgot about the files.. DARN!

[String]

Well, I've done an example with a string but...with numbers it would be possible or not? xD

I'm thought you are talking about converting String into Functions! XD
Oh well, you just read a file you want to, and when you got the number just use [YOUR NUMBER].to_f.

Now you converted it to fixnum. (Number)

[STRING]

Well... I didn't understand it that well XD, maybe because im really at the beginning of this part of rgss

Thanks a lot ^^

Well, may I ask for an example? xD
So, imagine that i create a new txt file even before opening project xD

I put data that I will need in rgss scripts, such as:

Text file, named 'example'
something => does_that
... (so on)

Now, using rgss to pick up that data and use it...
File.open("example", rb)
#stuff picking up that data <.<
File.close

So, what should I begin with there?

I don't think so.. I'm finding it out too..
I'm wondering like you too, but still.. you can't convert STRING into FUNCTIONS!
If you find it let me know because none of the computer languages (PHP, RGSS, VB, C+, etc.) can convert string into functions.

[FileTest.exist?(filename)]

You can use FileTest.exist?(filename) to check file if it is exist.
And use
Dir.glob("*."+filetype){|f|
  //Command (f = eachfile)
}
To each everyfile in the folder, you can put Dir.chdir(foldername){ to select a folder first. (Don't put an extra })

Use this to open a file.
File.open(filename,openingType){|f|
  //Command (f = eachfile)
}
You can choose a basic openingType from below..

• wb (Write)


• rb (Read)

f.read(characterCount) and f.write(value) will work for you as a command.
You can use writeFile(pathToFile+filename"."+filetype,value) to write a file right away too..

Hope this helped you.

Nice idea Dragon!

Tried to test this out.
Made a new project, popped this in with no changes, added an event to add items to my invitatory.
when I check my items.

Try this one out:

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# Item Art Color
# Version: 1.00
# Author : LiTTleDRAgo
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=



module LiTTleDRAgo
#------------------------------------------------------------------------------      
# Config Item Color
#         when (ID Item) then return (Type)
# or
#         when (ID Item) then return (Color)
#------------------------------------------------------------------------------      
  def self.ItemColor(i)
      case i
      when 2  then return Type('common')
      when 3  then return Type('epic')
      when 4  then return Type('common')
      when 5  then return Type('common')
      when 6  then return Color.new(119, 255, 0, 255)
      when 7  then return Color.new(120, 20 , 0, 255)
      when 8  then return Color.new(120, 20 , 0  , 255)
      when 9  then return Color.new(255, 255, 0  , 255)
      end
      return Color.normal_color
    end
#------------------------------------------------------------------------------      
# CONFIG END
#------------------------------------------------------------------------------      

#------------------------------------------------------------------------------     
# Config Weapon Color
#       when (ID Weapon) then return (Name Type)
# or
#       when (ID Weapon) then return (Color)
#------------------------------------------------------------------------------      
  def self.WeaponColor(i)
      case i
      when 2 then return Type('common')
      when 4 then return Type('rare')
      end
      return Color.normal_color
  end
#------------------------------------------------------------------------------      
# CONFIG END
#------------------------------------------------------------------------------      

#------------------------------------------------------------------------------      
# Config Armor Color
#       when (ID Armor) then return (Name Type)
# or
#       when (ID Armor) then return (Color)
#------------------------------------------------------------------------------      
  def self.ArmorColor(i)
      case i
      when 1 then return Type('fire')
      when 2 then return Type('common')
      when 3 then return Type('wind')
      when 6 then return Type('epic')
      when 7 then return Type('epic')
      end
      return Color.normal_color
  end
#------------------------------------------------------------------------------      
# CONFIG END
#------------------------------------------------------------------------------      

#------------------------------------------------------------------------------      
# Config Type Color
# when (Name Type) then return (Color)
#------------------------------------------------------------------------------      
  def self.Type(x)
    case x
    when 'common'  then return Color.new(255, 255, 0  , 255)
    when 'rare'    then return Color.new(120, 20 , 0  , 255)
    when 'epic'    then return Color.new(119, 255, 0  , 255)
    when 'awesome' then return Color.new(80 , 80 , 240, 255)
#------------------------------------------------------------------------------      
    when 'fire'    then return Color.red
    when 'ice'     then return Color.cyan
    when 'thunder' then return Color.purple
    when 'wind'    then return Color.green
    when 'earth'   then return Color.magenta
    when 'light'   then return Color.light_gray
    when 'dark'    then return Color.dark_gray
#------------------------------------------------------------------------------      
    end
    return Color.new(255, 255, 255, 255)
  end
  
end

#------------------------------------------------------------------------------      
# CONFIG END, DON'T EDIT BELOW UNLESS YOU KNOW WHAT YOU DO
#------------------------------------------------------------------------------      

#------------------------------------------------------------------------------
# SDK Check (This script will work with/without SDK)
#------------------------------------------------------------------------------
if Object.const_defined?('SDK')
 SDK.log('Item Art Color', 'LiTTleDRAgo', 4, '01.02.11')
 @drago_artcolors_disabled = true if !SDK.enabled?('Item Art Color')
end

if !@drago_artcolors_disabled
#------------------------------------------------------------------------------      
# THE SCRIPT START HERE
#------------------------------------------------------------------------------      
class Window_Base
 alias_method :drago_drawitemname, :draw_item_name
 def drago_item_colors(item,type = 0)
  return normal_color if item == nil
  @item_colored = true
  case item
  when RPG::Item   then return LiTTleDRAgo.ItemColor  (item.id)
  when RPG::Weapon then return LiTTleDRAgo.WeaponColor(item.id)
  when RPG::Armor  then return LiTTleDRAgo.ArmorColor (item.id)
  end 
  @item_colored = nil
  return disabled_color
 end

 def draw_item_name(item, x, y)
  drago_drawitemname(item, x, y)
  return if item == nil
  self.contents.font.color = drago_item_colors(item)
  self.contents.draw_text(x + 28, y, 212, 32, item.name) if @item_colored
 end
end

class Window_ShopBuy < Window_Selectable
 alias_method :drago_itemcolors_drawitem, :draw_item
 def draw_item(index)
   drago_itemcolors_drawitem(index)
   self.contents.font.color = drago_item_colors(@data[index])
   if @item_colored
     self.contents.draw_text(32,index * 32, 212, 32, @data[index].name, 0)
   end
 end
end

class Window_ShopSell < Window_Selectable
 alias_method :drago_itemcolors_drawitem, :draw_item
 def draw_item(index)
   drago_itemcolors_drawitem(index)
   self.contents.font.color = drago_item_colors(@data[index])
   if @item_colored
     x = 4 + index % 2 * (288 + 32)
     y = index / 2 * 32
     self.contents.draw_text(x + 28, y, 212, 32, @data[index].name)
   end
 end
end

class Window_EquipItem < Window_Selectable
 alias_method :drago_itemcolors_drawitem, :draw_item
 def draw_item(index)
   drago_itemcolors_drawitem(index)
   self.contents.font.color = drago_item_colors(@data[index])
   if @item_colored
     x = 4 + index % 2 * (288 + 32)
     y = index / 2 * 32
     self.contents.draw_text(x + 28, y, 212, 32, @data[index].name)
   end
 end
end  

class Window_Item < Window_Selectable
 alias_method :drago_itemcolors_drawitem, :draw_item
 def draw_item(index)
   drago_itemcolors_drawitem(index)
   self.contents.font.color = drago_item_colors(@data[index])
   if @item_colored 
     x = 4 + index % 2 * (288 + 32)
     y = index / 2 * 32
     self.contents.draw_text(x + 28, y, 212, 32, @data[index].name)
   end
 end
end

class Color
  def Color.white(a = 255)
    return Color.new(255, 255, 255, a)
  end
  def Color.black(a = 255)
    return Color.new(0, 0, 0, a)
  end
  def Color.red(a = 255)
    return Color.new(255, 0, 0, a)
  end
  def Color.green(a = 255)
    return Color.new(0, 255, 0, a)
  end
  def Color.blue(a = 255)
    return Color.new(0, 0, 255, a)
  end
  def Color.purple(a = 255)
    return Color.new(255, 0, 255, a)
  end
  def Color.yellow(a = 255)
    return Color.new(255, 255, 0, a)
  end
  def Color.cyan(a = 255)
    return Color.new(0, 255, 255, a)
  end
  def Color.magenta(a = 255)
    return Color.new(255, 255, 0, a)
  end
  def Color.light_gray(a = 255)
    return Color.new(192, 192, 192, a)
  end
  def Color.gray(a = 255)
    return Color.new(128, 128, 128, a)
  end
  def Color.dark_gray(a = 255)
    return Color.new(64, 64, 64, a)
  end
  def Color.pink(a = 255)
    return Color.new(255, 175, 175, a)
  end
  def Color.orange(a = 255)
    return Color.new(255, 200, 0, a)
  end
end
#--------------------------------------------------------------------------
# FOR STCMS
#--------------------------------------------------------------------------
if $stormtronics_cms
  class Window_CMSItem < Window_Selectable
   alias_method :drago_itemcolors_drawitem, :draw_item
    def draw_item(i)
      drago_itemcolors_drawitem(i)
      if @data[i].is_a?(RPG::Item) || @mode == nil
        number = $game_party.item_number(@data[i].id)
        self.contents.font.color = LiTTleDRAgo.ItemColor(@data[i].id)
        if !$game_party.item_can_use?(@data[i].id)
          self.contents.font.color.alpha = 128
        end
      elsif @data[i].is_a?(RPG::Weapon) 
        number = $game_party.weapon_number(@data[i].id)
        self.contents.font.color = LiTTleDRAgo.WeaponColor(@data[i].id)
        self.contents.font.color.alpha = 128
      elsif @data[i].is_a?(RPG::Armor) 
        number = $game_party.armor_number(@data[i].id)
        self.contents.font.color = LiTTleDRAgo.ArmorColor(@data[i].id)
        self.contents.font.color.alpha = 128
      end
      self.contents.draw_text(32, i*32, 212, 32, @data[i].name, 0)
      self.contents.draw_text(308, i*32, 16, 32, ':', 1)
      self.contents.draw_text(324, i*32, 24, 32, number.to_s, 2)
    end
  end
  
  class Window_EquipmentItem < Window_CMSItem
    alias_method :drago_itemcolors_drawitem, :draw_item
    def draw_item(i)
      drago_itemcolors_drawitem(i)
      case @data[i]
      when RPG::Weapon
        self.contents.font.color = LiTTleDRAgo.WeaponColor(@data[i].id)
        if !@actor.equippable?($data_weapons[@data[i].id])
          self.contents.font.color.alpha = 128
        end
        number = $game_party.weapon_number(@data[i].id)
      when RPG::Armor
        self.contents.font.color = LiTTleDRAgo.ArmorColor(@data[i].id)
        if !@actor.equippable?($data_armors[@data[i].id])
          self.contents.font.color.alpha = 128
        end
        number = $game_party.armor_number(@data[i].id)
      end
      self.contents.draw_text(32, i*32, 212, 32, @data[i].name, 0)
      self.contents.draw_text(308, i*32, 16, 32, ':', 1)
      self.contents.draw_text(324, i*32, 24, 32, number.to_s, 2)
    end
  end
  
  class Window_CMSEquipItem < Window_Selectable
    alias_method :drago_itemcolors_drawitem, :draw_item
    def draw_item(i)
     drago_itemcolors_drawitem(i)
      case @data[i]
      when RPG::Weapon 
        number = $game_party.weapon_number(@data[i].id)
        self.contents.font.color = LiTTleDRAgo.WeaponColor(@data[i].id)
      when RPG::Armor 
        number = $game_party.armor_number(@data[i].id)
        self.contents.font.color = LiTTleDRAgo.ArmorColor(@data[i].id)
      end
      self.contents.draw_text(32, i*32, 212, 32, @data[i].name, 0)
      self.contents.draw_text(212, i*32, 16, 32, ':', 1)
      self.contents.draw_text(228, i*32, 24, 32, number.to_s, 2)
    end
  end
end
#--------------------------------------------------------------------------
# SDK Check End
#--------------------------------------------------------------------------
end 
#--------------------------------------------------------------------------
# END OF SCRIPT
#--------------------------------------------------------------------------

[interString(url)]

Nevermind, here is the script.

Spoiler: ShowHide

module Win32
  def copymem(len)
    buf = "\0" * len
    Win32API.new("kernel32", "RtlMoveMemory", "ppl", "").call(buf, self, len)
    buf
  end  
end

# Extends the numeric class.
class Numeric
  include Win32
end

# Extends the string class.
class String
  include Win32
end
  
module Winsock

  DLL = "ws2_32"

  #--------------------------------------------------------------------------
  # * Accept Connection
  #--------------------------------------------------------------------------
  def self.accept(*args)
    Win32API.new(DLL, "accept", "ppl", "l").call(*args)
  end

  #--------------------------------------------------------------------------
  # * Bind
  #--------------------------------------------------------------------------
  def self.bind(*args)
    Win32API.new(DLL, "bind", "ppl", "l").call(*args)
  end

  #--------------------------------------------------------------------------
  # * Close Socket
  #--------------------------------------------------------------------------
  def self.closesocket(*args)
    Win32API.new(DLL, "closesocket", "p", "l").call(*args)
  end  
 
  #--------------------------------------------------------------------------
  # * Connect
  #--------------------------------------------------------------------------
  def self.connect(*args)
    Win32API.new(DLL, "connect", "ppl", "l").call(*args)
  end    
  
  #--------------------------------------------------------------------------
  # * Get host (Using Adress)
  #--------------------------------------------------------------------------
  def self.gethostbyaddr(*args)
    Win32API.new(DLL, "gethostbyaddr", "pll", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Get host (Using Name)
  #-------------------------------------------------------------------------- 
  def self.gethostbyname(*args)
    Win32API.new(DLL, "gethostbyname", "p", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Get host's Name
  #--------------------------------------------------------------------------
  def self.gethostname(*args)
    Win32API.new(DLL, "gethostname", "pl", "").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Get Server (Using Name)
  #--------------------------------------------------------------------------
  def self.getservbyname(*args)
    Win32API.new(DLL, "getservbyname", "pp", "p").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Convert Host Long To Network Long
  #--------------------------------------------------------------------------
  def self.htonl(*args)
    Win32API.new(DLL, "htonl", "l", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Convert Host Short To Network Short
  #--------------------------------------------------------------------------
  def self.htons(*args)
    Win32API.new(DLL, "htons", "l", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Inet Adress
  #--------------------------------------------------------------------------
  def self.inet_addr(*args)
    Win32API.new(DLL, "inet_addr", "p", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Inet N To A
  #--------------------------------------------------------------------------
  def self.inet_ntoa(*args)
    Win32API.new(DLL, "inet_ntoa", "l", "p").call(*args)
  end  
  
  #--------------------------------------------------------------------------
  # * Listen
  #--------------------------------------------------------------------------
  def self.listen(*args)
    Win32API.new(DLL, "listen", "pl", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Recieve
  #--------------------------------------------------------------------------
  def self.recv(*args)
    Win32API.new(DLL, "recv", "ppll", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Select
  #--------------------------------------------------------------------------
  def self.select(*args)
    Win32API.new(DLL, "select", "lpppp", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Send
  #--------------------------------------------------------------------------
  def self.send(*args)
    Win32API.new(DLL, "send", "ppll", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Set Socket Options
  #--------------------------------------------------------------------------
  def self.setsockopt(*args)
    Win32API.new(DLL, "setsockopt", "pllpl", "l").call(*args)
  end  
  
  #--------------------------------------------------------------------------
  # * Shutdown
  #--------------------------------------------------------------------------
  def self.shutdown(*args)
    Win32API.new(DLL, "shutdown", "pl", "l").call(*args)
  end
  
  #--------------------------------------------------------------------------
  # * Socket
  #--------------------------------------------------------------------------
  def self.socket(*args)
    Win32API.new(DLL, "socket", "lll", "l").call(*args)  
  end
  
  #--------------------------------------------------------------------------
  # * Get Last Error
  #--------------------------------------------------------------------------
  def self.WSAGetLastError(*args)
    Win32API.new(DLL, "WSAGetLastError", "", "l").call(*args)
  end
 
end

if !Object.const_defined?(:Socket) # for compatibility

#===============================================================================
# ** Socket - Creates and manages sockets.
#-------------------------------------------------------------------------------
# Author    Ruby
# Version   1.8.1
#===============================================================================
class Socket

  #--------------------------------------------------------------------------
  # * Constants
  #--------------------------------------------------------------------------
  AF_UNSPEC                 = 0  
  AF_UNIX                   = 1
  AF_INET                   = 2
  AF_IPX                    = 6
  AF_APPLETALK              = 16

  PF_UNSPEC                 = 0  
  PF_UNIX                   = 1
  PF_INET                   = 2
  PF_IPX                    = 6
  PF_APPLETALK              = 16

  SOCK_STREAM               = 1
  SOCK_DGRAM                = 2
  SOCK_RAW                  = 3
  SOCK_RDM                  = 4
  SOCK_SEQPACKET            = 5
  
  IPPROTO_IP                = 0
  IPPROTO_ICMP              = 1
  IPPROTO_IGMP              = 2
  IPPROTO_GGP               = 3
  IPPROTO_TCP               = 6
  IPPROTO_PUP               = 12
  IPPROTO_UDP               = 17
  IPPROTO_IDP               = 22
  IPPROTO_ND                = 77
  IPPROTO_RAW               = 255
  IPPROTO_MAX               = 256

  SOL_SOCKET                = 65535
  
  SO_DEBUG                  = 1
  SO_REUSEADDR              = 4
  SO_KEEPALIVE              = 8
  SO_DONTROUTE              = 16
  SO_BROADCAST              = 32
  SO_LINGER                 = 128
  SO_OOBINLINE              = 256
  SO_RCVLOWAT               = 4100
  SO_SNDTIMEO               = 4101
  SO_RCVTIMEO               = 4102
  SO_ERROR                  = 4103
  SO_TYPE                   = 4104
  SO_SNDBUF                 = 4097
  SO_RCVBUF                 = 4098
  SO_SNDLOWAT               = 4099
  
  TCP_NODELAY               =	1
  
  MSG_OOB                   = 1
  MSG_PEEK                  = 2
  MSG_DONTROUTE             = 4
  
  IP_OPTIONS                =	1
  IP_DEFAULT_MULTICAST_LOOP =	1
  IP_DEFAULT_MULTICAST_TTL  =	1
  IP_MULTICAST_IF           =	2
  IP_MULTICAST_TTL          =	3
  IP_MULTICAST_LOOP         =	4
  IP_ADD_MEMBERSHIP         =	5
  IP_DROP_MEMBERSHIP        =	6
  IP_TTL                    =	7
  IP_TOS                    =	8
  IP_MAX_MEMBERSHIPS        =	20

  EAI_ADDRFAMILY            = 1
  EAI_AGAIN                 = 2
  EAI_BADFLAGS              = 3
  EAI_FAIL                  = 4
  EAI_FAMILY                = 5
  EAI_MEMORY                = 6
  EAI_NODATA                = 7
  EAI_NONAME                = 8
  EAI_SERVICE               = 9
  EAI_SOCKTYPE              = 10
  EAI_SYSTEM                = 11
  EAI_BADHINTS              = 12
  EAI_PROTOCOL              = 13
  EAI_MAX                   = 14
  AI_PASSIVE                = 1
  AI_CANONNAME              = 2
  AI_NUMERICHOST            = 4
  AI_MASK                   = 7
  AI_ALL                    = 256
  AI_V4MAPPED_CFG           = 512
  AI_ADDRCONFIG             = 1024
  AI_DEFAULT                = 1536
  AI_V4MAPPED               = 2048
  #--------------------------------------------------------------------------
  # * Returns the associated IP address for the given hostname.
  #--------------------------------------------------------------------------  
  def self.getaddress(host)
    gethostbyname(host)[3].unpack("C4").join(".")
  end
  
  #--------------------------------------------------------------------------
  # * Returns the associated IP address for the given hostname.
  #--------------------------------------------------------------------------  
  def self.getservice(serv)
    case serv
    when Numeric
      return serv
    when String
      return getservbyname(serv)
    else
      raise "Please use an integer or string for services."
    end
  end

  #--------------------------------------------------------------------------
  # * Returns information about the given hostname.
  #--------------------------------------------------------------------------
  def self.gethostbyname(name)
    raise SocketError::ENOASSOCHOST if (ptr = Winsock.gethostbyname(name)) == 0
    host = ptr.copymem(16).unpack("iissi")
    [host[0].copymem(64).split("\0")[0], [], host[2], host[4].copymem(4).unpack("l")[0].copymem(4)]
  end
  
  #--------------------------------------------------------------------------
  # * Returns the user's hostname.
  #--------------------------------------------------------------------------  
  def self.gethostname
    buf = "\0" * 256
    Winsock.gethostname(buf, 256)
    buf.strip
  end
  
  #--------------------------------------------------------------------------
  # * Returns information about the given service.
  #--------------------------------------------------------------------------
  def self.getservbyname(name)
    case name
    when /echo/i
      return 7
    when /daytime/i
      return 13
    when /ftp/i
      return 21
    when /telnet/i
      return 23
    when /smtp/i
      return 25
    when /time/i
      return 37
    when /http/i
      return 80
    when /pop/i
      return 110
    else
      #Network.testing? != 0 ? (Network.testresult(true)) : (raise "Service not recognized.")
      #return if Network.testing? == 2
    end
  end
  
  #--------------------------------------------------------------------------
  # * Creates an INET-sockaddr struct.
  #--------------------------------------------------------------------------  
  def self.sockaddr_in(port, host)
    begin
      [AF_INET, getservice(port)].pack("sn") + gethostbyname(host)[3] + [].pack("x8")
    rescue
      #Network.testing? != 0 ? (Network.testresult(true)): (nil)
      #return if Network.testing? == 2
    rescue Hangup
      #Network.testing? != 0 ? (Network.testresult(true)): (nil)
      #return if Network.testing? == 2
    end
  end

  #--------------------------------------------------------------------------
  # * Creates a new socket and connects it to the given host and port.
  #--------------------------------------------------------------------------  
  def self.open(*args)
    socket = new(*args)
    if block_given?
      begin
        yield socket
      ensure
        socket.close
      end
    end
    nil
  end

  #--------------------------------------------------------------------------
  # * Creates a new socket.
  #--------------------------------------------------------------------------  
  def initialize(domain, type, protocol)
    SocketError.check if (@fd = Winsock.socket(domain, type, protocol)) == -1
    @fd
  end

  #--------------------------------------------------------------------------
  # * Accepts incoming connections.
  #--------------------------------------------------------------------------  
  def accept(flags = 0)
    buf = "\0" * 16
    SocketError.check if Winsock.accept(@fd, buf, flags) == -1
    buf
  end

  #--------------------------------------------------------------------------
  # * Binds a socket to the given sockaddr.
  #--------------------------------------------------------------------------  
  def bind(sockaddr)
    SocketError.check if (ret = Winsock.bind(@fd, sockaddr, sockaddr.size)) == -1
    ret
  end

  #--------------------------------------------------------------------------
  # * Closes a socket.
  #--------------------------------------------------------------------------  
  def close
    SocketError.check if (ret = Winsock.closesocket(@fd)) == -1
    ret
  end

  #--------------------------------------------------------------------------
  # * Connects a socket to the given sockaddr.
  #--------------------------------------------------------------------------  
  def connect(sockaddr)
    #return if Network.testing? == 2
    SocketError.check if (ret = Winsock.connect(@fd, sockaddr, sockaddr.size)) == -1
    ret
  end

  #--------------------------------------------------------------------------
  # * Listens for incoming connections.
  #--------------------------------------------------------------------------  
  def listen(backlog)
    SocketError.check if (ret = Winsock.listen(@fd, backlog)) == -1
    ret
  end
  
  #--------------------------------------------------------------------------
  # * Checks waiting data's status.
  #--------------------------------------------------------------------------  
  def select(timeout) # timeout in seconds
    SocketError.check if (ret = Winsock.select(1, [1, @fd].pack("ll"), 0, 0, [timeout.to_i, 
         (timeout * 1000000).to_i].pack("ll"))) == -1
    ret
  end
  
  #--------------------------------------------------------------------------
  # * Checks if data is waiting.
  #--------------------------------------------------------------------------  
  def ready?
    not select(0) == 0
  end  

  #--------------------------------------------------------------------------
  # * Reads data from socket.
  #--------------------------------------------------------------------------  
  def read(len)
    buf = "\0" * len
    Win32API.new("msvcrt", "_read", "lpl", "l").call(@fd, buf, len)
    buf
  end
  
  #--------------------------------------------------------------------------
  # * Returns received data.
  #--------------------------------------------------------------------------  
  def recv(len, flags = 0)
    retString=""
    remainLen=len
    while remainLen > 0
     buf = "\0" * remainLen
     retval=Winsock.recv(@fd, buf, buf.size, flags)
     SocketError.check if retval == -1
     # Note: Return value may not equal requested length
     remainLen-=retval
     retString+=buf[0,retval]
    end
    return retString
  end
  
  #--------------------------------------------------------------------------
  # * Sends data to a host.
  #--------------------------------------------------------------------------  
  def send(data, flags = 0)
    SocketError.check if (ret = Winsock.send(@fd, data, data.size, flags)) == -1
    ret
  end
  
  #--------------------------------------------------------------------------
  # * Recieves file from a socket
  #     size  : file size
  #     scene : update scene boolean 
  #--------------------------------------------------------------------------
  def recv_file(size,scene=false,file="")
    data = []
    size.times do |i|
      if scene == true
        $scene.recv_update(size,i,file)  if i%((size/1000)+1)== 0
      else
        Graphics.update if i%1024 == 0
      end
      data << recv(1)
    end
    return data
  end
  def recvTimeout
    if select(10)==0
      raise Hangup.new("Timeout")
    end
    return recv(1)
  end
  #--------------------------------------------------------------------------
  # * Gets
  #--------------------------------------------------------------------------
  def gets
    # Create buffer
    message = ""
    # Loop Until "end of line"
    count=0
    while true
      x=select(0.05)
      if x==0
       count+=1
       Graphics.update if count%10==0
       raise Errno::ETIMEOUT if count>200
       next
      end
      ch = recv(1)
      break if ch == "\n"
      message += ch
    end
    # Return recieved data 
    return message
  end
  
  #--------------------------------------------------------------------------
  # * Writes data to socket.
  #--------------------------------------------------------------------------  
  def write(data)
    Win32API.new("msvcrt", "_write", "lpl", "l").call(@fd, data, 1)
  end

end

#===============================================================================
# ** TCPSocket - Creates and manages TCP sockets.
#-------------------------------------------------------------------------------
# Author    Ruby
# Version   1.8.1
#===============================================================================

#-------------------------------------------------------------------------------
# Begin SDK Enabled Check
#-------------------------------------------------------------------------------
  
class TCPSocket < Socket

  #--------------------------------------------------------------------------
  # * Creates a new socket and connects it to the given host and port.
  #--------------------------------------------------------------------------  
  def self.open(*args)
    socket = new(*args)
    if block_given?
      begin
        yield socket
      ensure
        socket.close
      end
    end
    nil
  end

  #--------------------------------------------------------------------------
  # * Creates a new socket and connects it to the given host and port.
  #--------------------------------------------------------------------------  
  def initialize(host, port)
    super(AF_INET, SOCK_STREAM, IPPROTO_TCP)
    connect(Socket.sockaddr_in(port, host))
  end
  
end

#==============================================================================
# ** SocketError
#------------------------------------------------------------------------------
# Default exception class for sockets.
#==============================================================================
class SocketError < StandardError
  ENOASSOCHOST = "getaddrinfo: no address associated with hostname."
  def self.check
    errno = Winsock.WSAGetLastError
    #if not Network.testing? == 1
      raise Errno.const_get(Errno.constants.detect { |c| Errno.const_get(c).new.errno == errno })
    #else
    #  errno != 0 ? (Network.testresult(true)) : (Network.testresult(false)) 
    #end
  end
end

end # !Object.const_defined?(:Socket)

def interData(url, filename=nil, depth=0)
 userAgent="Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.14) Gecko/2009082707 Firefox/3.0.14"
 if depth>10
  raise "Redirection level too deep"
 end
 if url[/^http:\/\/([^\/]+)(.*)$/]
  host=$1
  path=$2
  path="/" if path.length==0
  request="GET #{path} HTTP/1.1\nUser-Agent: #{userAgent}\nPragma: no-cache\nHost: #{host}\nProxy-Connection: Close\n\n"
  return httpRequest(host, request, filename, depth)
 end
 return ""
end

def httpRequest(host, request, filename=nil, depth=0)
  if depth>10
   raise "Redirection level too deep"
  end
  socket=::TCPSocket.new(host, 80)
  time=Time.now.to_i
  begin
   socket.send(request)
   result=socket.gets
   data=""
   # Get the HTTP result
   if result[/^HTTP\/1\.[01] (\d+).*/]
    errorcode=$1.to_i
    if errorcode>=400 && errorcode<500
     raise "HTTP Error #{errorcode}"
    end
    headers={}
    # Get the response headers
    while true
     result=socket.gets.sub(/\r$/,"")
     break if result==""
     if result[/^([^:]+):\s*(.*)/]
       headers[$1]=$2
     end
    end
    length=-1
    chunked=false
    if headers["Content-Length"]
     length=headers["Content-Length"].to_i
    end
    if headers["Transfer-Encoding"]=="chunked"
     chunked=true
    end
    if headers["Location"] && errorcode >= 300 && errorcode < 400
     socket.close rescue socket=nil
     return pbDownloadData(headers["Location"],filename,depth+1)
    end
    if chunked==true
     # Chunked content
     while true
      lengthline=socket.gets.sub(/\r$/,"")
      length=lengthline.to_i(16)
      break if length==0
      while Time.now.to_i-time>=5 || socket.select(10)==0
       time=Time.now.to_i
       Graphics.update
      end
      data+=socket.recv(length)
      socket.gets
     end
    elsif length==-1
     # No content length specified
     while true
      if socket.select(500)==0
       break
      else
       while Time.now.to_i-time>=5 || socket.select(10)==0
        time=Time.now.to_i
        Graphics.update
       end
       data+=socket.recv(1)
      end
     end
    else
     # Content length specified
     while length>0
      chunk=[length,4096].min
      while Time.now.to_i-time>=5 || socket.select(10)==0
       time=Time.now.to_i
       Graphics.update
      end
      data+=socket.recv(chunk)
      length-=chunk
     end
    end
   end
   if filename
    File.open(filename,"wb"){|f|
     f.write(data)
    }
   else
    return data
   end
  ensure
   socket.close rescue socket=nil
  end
 return ""
end

def interString(url)
 begin
  data=interData(url)
  return data
 rescue
  return ""
 end 
end

def interFile(url, file)
 begin
  interData(url,file)
 rescue
 end
end

You can only use interString(url) and interFile(url,file). Have fun!

Yep, Internet Source Code/String Downloader!

Hmmmm....Indeed thanks much Blizz.

Press search before you ask someone man.

Well if you need it...  someone gives me a script that allows you select the leader in a little window when you hit a button... in my case is ctrl... if you are dead... the windows appears and let you select the leader that continues...

module BlizzABS
  
  
  class Controller
  
    def update_control
      # get pixel movement rate
      pix = $BlizzABS.pixel
      # reset move speed
      player.move_speed = player.normal_speed
      # reset spriteset name
      player.character_name = player.character_name_org
      # if allowed to change speed
      unless $game_system.map_interpreter.running? ||
          player.move_route_forcing || $game_temp.message_window_showing
        # if run button works and running
        if $game_system.running_button && Input.press?(Input::Run)
          # set running speed
          player.move_speed = Config::RUN_SPEED
        # if sneak button works and sneaking
        elsif $game_system.sneaking_button && Input.press?(Input::Sneak) ||
            Config::SNEAK_SPEED > 0 && Config::SNEAK_ON_CHARGE && player.charging?
          # set sneaking speed
          player.move_speed = Config::SNEAK_SPEED
        end
      end
      # if battler exists and either dead or select triggered
      if player.battler != nil && ($game_system.select_button &&
          Input.trigger?(Input::Select) || player.battler.dead?)
        # switch to next valid actor
        $scene = Scene_Player_Select.new
      end 
      # setup sprite animation
      player.sprite_animation_setup
      # update action
      player.update_action
      # if allowed to turn and pressed turning button or defending
      if ((player.ai.act.defend? && player.attacked == 0) ||
          $game_system.turn_button && Input.press?(Input::Turn)) &&
          !player.moving? && !$game_system.map_interpreter.running? &&
          !player.move_route_forcing && !$game_temp.message_window_showing
        # get input depending on confusion
        input = (player.restriction == 3 ? 10 - Input.dir4 : Input.dir4)
        # depending on input turn
        case input
        when 2 then player.turn_down
        when 4 then player.turn_left
        when 6 then player.turn_right
        when 8 then player.turn_up
        end
        # updates any attacked action
        player.update_attacked
        # abort method
        return nil
      end
      # updates any attacked action
      player.update_attacked
      # if acting
      if player.in_action > 0
        # decrease action counter if in_action is greater than 0
        player.in_action -= 1 if player.in_action > 0
        # return data
        return [player.moving?, player.real_x, player.real_y]
      end
      # if allowed to move
      unless $game_system.map_interpreter.running? ||
          player.move_route_forcing || $game_temp.message_window_showing
        # if jump button was pressed and not already jumping
        if $game_system.jumping_button && Input.trigger?(Input::Jump) &&
            !player.jumping? && player.restriction < 4
          # set to jump
          @memory_jump = true
        end
        # if not moving
        unless player.moving?
          # get jumping range
          range = Config::JUMPING
          # if jumping turned on and not jumping and jumped
          if range > 0 && !player.jumping? && @memory_jump
            # if sneaking or running is possible
            if Config::RUN_SPEED > 0 || Config::SNEAK_SPEED > 0
              # get difference between current speed and normal speed
              dplus = player.move_speed - player.normal_speed
            else
              # difference is 0
              dplus = 0
            end
            # get direction
            direction = $game_system._8_way ? Input.dir8 : Input.dir4
            # set jumping direction
            x, y = Cache::DirOffsets[direction]
            # jump into direction with considering running/sneaking
            player.jump(x*range + x*dplus, y*range + y*dplus, direction)
          # if not already jumping
          elsif !player.jumping?
            # move
            move($game_system._8_way ? Input.dir8 : Input.dir4)
            # allow idle if no movement
            player.idle_allowed = !player.moving?
          end
          # not jumping anymore
          @memory_jump = false
        end
      end
      # return data
      return [player.moving?, player.real_x, player.real_y]
    end
  end
end
#==============================================================================
# Scene Player Select
#==============================================================================
class Scene_Player_Select
   
  def main
    @spriteset = Spriteset_Map.new
    @change_char = Window_Player_Select.new
    @change_char.x = 320 - (@change_char.width / 2)
    @change_char.y = 240 - (@change_char.height / 2)
    # create HUD if HUD is turned on and HUD active
    @hud = Hud.new if BlizzABS::Config::HUD_ENABLED && $game_system.hud
    # if ASSIGNMENT is turned on and assignment display active
    if BlizzABS::Config::HOTKEYS && $game_system.hotkeys
      # create assignment display
      @hotkeys = Hotkey_Assignment.new
    end
    # if MINIMAP is turned on and minimap active
    if BlizzABS::Config::MINIMAP && $game_system.minimap > 0
      # create HUD
      @minimap = Minimap.new
      # create HUD
      @minimap.update
    end
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      break if $scene != self
    end
    Graphics.freeze
    [@hud, @hotkeys, @minimap].each {|s| s.dispose if s != nil}
    @change_char.dispose
    @spriteset.dispose
  end
  
  def update
    @change_char.update
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      $game_party.swap_actor(@change_char.index)
      $scene = Scene_Map.new
    end
  end
  
end
#==============================================================================
# Window Plyer Select
#==============================================================================
class Window_Player_Select < Window_Selectable
  
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(350, 200, 150,($game_party.actors.size*32)+ 32)
    @column_max = 1
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @item_max = $game_party.actors.size
    self.contents = Bitmap.new(width - 32, (@item_max*32))
    (0...@item_max).each{|i|draw_item(i)}
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    name = $game_party.actors[index].name
    y = index * 32
    self.contents.draw_text(4, y, 100, 32, name.to_s)
  end
end
#==============================================================================
# Game_Party
#==============================================================================
class Game_Party
  
  def swap_actor(switch_id)
    hold = @actors[0]
    @actors[0] = @actors[switch_id]
    @actors[switch_id] = hold
    $game_player.refresh
  end
  
end

Put it below Bliz abs

Awesome! *chucked it in the script bucket*

You can count...wait, no you can't. Otherwise I wouldn't be saying this. Woops.

Thanks for the script Blizz.
It works fine for me.. VIRUS!!!