Project1

标题: “字符串”技能树 [打印本页]
作者: 恐惧剑刃    时间: 2013-10-18 22:02
标题: “字符串”技能树
本帖最后由 恋′挂机 于 2013-10-18 22:06 编辑

源自：http://rpg.blue/thread-336098-1-1.html


看似很复杂，其实很简单。


脚本参考，当然要自行做一些整合

选择窗口
  1. # --------------------
  2.   # 重要！！！！！！！！
  3.   # --------------------
  4.   attr_accessor :skill_case
  5.   attr_accessor :shuzhi_hash
复制代码
初始化
  1. # --------------------
  2.     # 重要！！！！！！！！
  3.     # --------------------
  4.    
  5.     # 判断选择状态用的哈希表
  6.     @skill_case = {}
  7.    
  8.     # 树枝的哈希表
  9.     @shuzhi_hash = {}
复制代码
添加
  1. # ------------------
  2.     # 描绘图标与树枝
  3.     # ------------------
  4.    
  5.     # 循环准备
  6.     xunhuan_time = 0
  7.    
  8.     jineng_time = 0
  9.    
  10.     # 简化
  11.     #@shuzhi_array.size - 1
  12.     #@shuzhi_array[jianqu1].split(/◎/)[0].to_i
  13.       
  14.     jianqu1 = @shuzhi_array.size - 1
  15.     jxmh = @shuzhi_array[jianqu1].split(/◎/)[0].to_i
  16.    
  17.     # 矩形
  18.     rect = Rect.new(0, 0, 24, 24)

  20.       
  21.     # 循环
  22.     for i in @shuzhi_array
  23.       # 坐标
  24.       x = (xunhuan_time % jxmh) * 32 + 4
  25.       y = (xunhuan_time / jxmh) * 32 + 4
  26.       # 不等与"☆"描绘
  27.       if i != "☆"
  28.         case i
  29.         # 技能图标
  30.         when "★"
  31.           # 图标透明度
  32.           unless @actor.skills.include?(@skill[jineng_time].id)
  33.             opacity_icon = 160
  34.           else
  35.             opacity_icon = 255
  36.           end
  37.           self.contents.blt(x, y, @icon[jineng_time], rect, opacity_icon)
  38.           # 以XY坐标为主键技能为值
  39.           @skill_case[x.to_s+"◎"+y.to_s] = @skill[jineng_time]
  40.           jineng_time += 1
  41.         # 树枝
  42.         when "→"
  43.           self.contents.blt(x, y, @shuzhi_picture[0], rect)
  44.           # 以XY坐标为主键方向字符为值
  45.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "→"
  46.         when "←"
  47.           self.contents.blt(x, y, @shuzhi_picture[1], rect)
  48.           # 以XY坐标为主键方向字符为值
  49.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "←"
  50.         when "↑"
  51.           self.contents.blt(x, y, @shuzhi_picture[2], rect)
  52.           # 以XY坐标为主键方向字符为值
  53.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↑"
  54.         when "↓"
  55.           self.contents.blt(x, y, @shuzhi_picture[3], rect)
  56.           # 以XY坐标为主键方向字符为值
  57.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↓"
  58.         when "↖"
  59.           self.contents.blt(x, y, @shuzhi_picture[4], rect)
  60.           # 以XY坐标为主键方向字符为值
  61.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↖"
  62.         when "↗"
  63.           self.contents.blt(x, y, @shuzhi_picture[5], rect)
  64.           # 以XY坐标为主键方向字符为值
  65.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↗"
  66.         when "↘"
  67.           self.contents.blt(x, y, @shuzhi_picture[6], rect)
  68.           # 以XY坐标为主键方向字符为值
  69.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↘"
  70.         when "↙"
  71.           self.contents.blt(x, y, @shuzhi_picture[7], rect)
  72.           # 以XY坐标为主键方向字符为值
  73.           @shuzhi_hash[x.to_s+"◎"+y.to_s] = "↙"
  74.         end
  75.       end
  76.       # 项目判断
  77.       xunhuan_time += 1
  78.     end
复制代码
帮助刷新
  1. # 刷新帮助
  2.   def update_help
  3.    
  4.    
  5.     # 为了刷新，就只好牺牲内存了
  6.    
  7.     # 判断
  8.     #if self.index != @old_index
  9.       # 隐藏帮助
  10.       @help_window.visible = false
  11.       # 简化写法
  12.       jianqu1 = @shuzhi_array.size - 1
  13.       jxmh = @shuzhi_array[jianqu1].split(/◎/)[0].to_i
  14.       # 帮助坐标
  15.       x = (self.index % jxmh) * 32
  16.       y = (self.index / jxmh) * 32
  17.       # 循环
  18.       for i in @skill_case.keys
  19.         # 判断
  20.         if i == (x+4).to_s+"◎"+(y+4).to_s
  21.           @help_window.set_text(
  22.           x + 50, y, @skill_case[(x+4).to_s+"◎"+(y+4).to_s], @actor)
  23.         end
  24.       end
  25.     #  @old_index = self.index
  26.     #end
  27.    
  28.   end
复制代码
  1.   # 刷新选择窗口
  2.   def update_select_window
  3.     # B键的按下
  4.     if Input.trigger?(Input::B)
  5.       $scene = Scene_Map.new
  6.     end
  7.     # C键的按下
  8.     if Input.trigger?(Input::C)
  9.       
  10.       # 获取坐标，以坐标为媒介（主键）获取相关信息
  11.       
  12.       # 坐标
  13.       jianqu1 = SHEZHI::ACTOR_ARRAY[@actor.id].size - 1
  14.       jxmh = SHEZHI::ACTOR_ARRAY[@actor.id][jianqu1].split(/◎/)[0].to_i
  15.       
  16.       x = (@select_window.index % jxmh) * 32 + 4
  17.       y = (@select_window.index / jxmh) * 32 + 4
  18.       
  19.       # 判断是否选中技能
  20.       if @select_window.skill_case[x.to_s+"◎"+y.to_s] != nil
  21.         # 简化，方便之后使用skill值
  22.         skill = @select_window.skill_case[x.to_s+"◎"+y.to_s]
  23.         # 判断技能是否已经领悟
  24.         unless @actor.skills.include?(skill)

  26.           # ------------------
  27.           # 判断技能树关系
  28.           # （判断基础技能是否学习）
  29.           # ------------------
  30.           # 连接线：→←↑↓↖↗↘↙
  31.           # ------------------
  32.          
  33.           # 判断准备
  34.           base_skill_array = []
  35.          
  36.           # 左边：
  37.           x_copy = x - 32
  38.           y_copy = y
  39.          
  40.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  41.             # 简化
  42.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  43.             # 分歧
  44.             if shuzhi == "→"

  46.               # 获得基础技能坐标
  47.               x_copy = x - 64
  48.               y_copy = y
  49.               # 简化，通过基础技能坐标获取基础技能
  50.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  51.               base_skill_array << base
  52.               
  53.             end
  54.           end
  55.          
  56.           # 右边：
  57.           x_copy = x + 32
  58.           y_copy = y
  59.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  60.             # 简化
  61.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  62.             # 分歧
  63.             if shuzhi == "←"

  65.               # 获得基础技能坐标
  66.               x_copy = x + 64
  67.               y_copy = y
  68.               # 简化，通过基础技能坐标获取基础技能
  69.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  70.               base_skill_array << base
  71.               
  72.             end
  73.           end
  74.          
  75.           # 上边：
  76.           x_copy = x
  77.           y_copy = y - 32
  78.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  79.             # 简化
  80.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  81.             # 分歧
  82.             if shuzhi == "↓"

  84.               # 获得基础技能坐标
  85.               x_copy = x
  86.               y_copy = y - 64
  87.               # 简化，通过基础技能坐标获取基础技能
  88.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  89.               base_skill_array << base

  91.             end
  92.           end
  93.          
  94.           # 下边：
  95.           x_copy = x
  96.           y_copy = y + 32
  97.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  98.             # 简化
  99.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  100.             # 分歧
  101.             if shuzhi == "↑"

  103.               # 获得基础技能坐标
  104.               x_copy = x
  105.               y_copy = y + 64
  106.               # 简化，通过基础技能坐标获取基础技能
  107.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  108.               base_skill_array << base

  110.             end
  111.           end
  112.          
  113.           # 左上方：
  114.           x_copy = x - 32
  115.           y_copy = y - 32
  116.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  117.             # 简化
  118.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  119.             # 分歧
  120.             if shuzhi == "↘"

  122.               # 获得基础技能坐标
  123.               x_copy = x - 64
  124.               y_copy = y - 64
  125.               # 简化，通过基础技能坐标获取基础技能
  126.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  127.               base_skill_array << base

  129.             end
  130.           end
  131.          
  132.           # 右上方：
  133.           x_copy = x + 32
  134.           y_copy = y - 32
  135.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  136.             # 简化
  137.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  138.             # 分歧
  139.             if shuzhi == "↙"

  141.               # 获得基础技能坐标
  142.               x_copy = x + 64
  143.               y_copy = y - 64
  144.               # 简化，通过基础技能坐标获取基础技能
  145.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  146.               base_skill_array << base

  148.             end
  149.           end
  150.          
  151.           # 右下方：
  152.           x_copy = x + 32
  153.           y_copy = y + 32
  154.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  155.             # 简化
  156.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  157.             # 分歧
  158.             if shuzhi == "↖"

  160.               # 获得基础技能坐标
  161.               x_copy = x + 64
  162.               y_copy = y + 64
  163.               # 简化，通过基础技能坐标获取基础技能
  164.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  165.               base_skill_array << base

  167.             end
  168.           end
  169.          
  170.           # 左下方：
  171.           x_copy = x - 32
  172.           y_copy = y + 32
  173.           if @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s] != nil
  174.             # 简化
  175.             shuzhi = @select_window.shuzhi_hash[x_copy.to_s+"◎"+y_copy.to_s]
  176.             # 分歧
  177.             if shuzhi == "↗"

  179.               # 获得基础技能坐标
  180.               x_copy = x - 64
  181.               y_copy = y + 64
  182.               # 简化，通过基础技能坐标获取基础技能
  183.               base = @select_window.skill_case[x_copy.to_s+"◎"+y_copy.to_s]
  184.               base_skill_array << base

  186.             end
  187.           end
  188.          
  189.           # 处理干净
  190.           @yes_or_no = nil
  191.          
  192.           # 正式判断
  193.           if base_skill_array != []
  194.             for i in base_skill_array
  195.               # 任意一项基础技能已经领悟，把true就赋予@yes_or_no
  196.               if @actor.skills.include?(i.id)
  197.                 @yes_or_no = true
  198.               end
  199.             end
  200.             if @yes_or_no
  201.               # 领悟技能
  202.               @actor.learn_skill(skill.id)
  203.               # 选择窗口刷新
  204.               @select_window.refresh
  205.               # 刷新帮助窗口
  206.               @select_window.update_help
  207.             end
  208.           else
  209.             # 领悟技能
  210.             @actor.learn_skill(skill.id)
  211.             # 选择窗口刷新
  212.             @select_window.refresh
  213.             # 刷新帮助窗口
  214.             @select_window.update_help
  215.           end

  217.         end#include?
  218.       end#select
  219.       
  220.     end#if input c
  221.   end#def
复制代码





欢迎光临 Project1 (https://rpg.blue/) Powered by Discuz! X3.1