JAES XP2.1 技能养成+能量技能双系统 - Project1

# -----------------------------------------------------------------------------
# Minax
# ver:1.0 (compressed by orzFly)
# date:2011.8.23
# -by.Ultra
# -----------------------------------------------------------------------------
# ◆性能：
# Minax 工作效率测试
# 测试电脑：1.81 GHz 1.5G RAM
# MIN类1秒处理>30万个单元，同时处理上限为300万个单元（临近10秒备份）
# MAX类1秒处理>150万个单元，同时处理上限为2000万个单元（临近10秒备份）
# ◆函数：
# Minax 全部函数简要
# 函数(参数) * 函数处理简要
# ━ minax_table(size) * 生成 MIN 与 MAX 多维数组
# ━ min_full?(type,unit) * 判断MIN是否达到上限 MAX
# ┏ min_set(type,set) * 用数据设置到 MIN
# ┗ max_set(type,set) * 用数据设置到 MAX
# ┏ min_all_cover(type,value) * MIN 全部代入某值
# ┗ max_all_cover(type,value) * MAX 全部代入某值
# ┏ min_all_pr(type,value) * MIN 全部增减某值
# ┗ max_all_pr(type,value) * MAX 全部增减某值
# ┏ min_range_cover(type,value,qx,zx,qy,zy,qz,zz) * MIN 范围代入某值
# ┗ max_range_cover(type,value,qx,zx,qy,zy,qz,zz) * MAX 范围代入某值
# ┏ min_range_pr(type,value,qx,zx,qy,zy,qz,zz) * MIN 范围增减某值
# ┗ max_range_pr(type,value,qx,zx,qy,zy,qz,zz) * MAX 范围增减某值
# ┏ min_unit_cover(type,unit,value) * MIN 单元代入某值
# ┗ max_unit_cover(type,unit,value) * MAX 单元代入某值
# ┏ min_unit_pr(type,unit,value) * MIN 单元增减某值
# ┗ max_unit_pr(type,unit,value) * MAX 单元增减某值
# ◆参数：
# Minax 全部参数规格
# 参数 * 参数结构规格 * 参数内容规格
# size * {"T"=>[x,y,z],""=>[]…} * T为字符串 x,y,z为整数
# type * "T" * T为字符串
# set * [[x,y,z,num],[]…] * x,y,z值为每维范围内 num为整数，浮点数
# value * num * num为整数，浮点数
# unit * [x,y,z] * x,y,z值为每维范围内
# qx,qy,qz * x,y,z * x,y,z值为每维范围内
# zx,zy,zz * x,y,z * x,y,z值为每维范围内
# -----------------------------------------------------------------------------
class Minax
attr_accessor :min
attr_accessor :max
attr_accessor :size
def initialize
@min = {}
@max = {}
@size = {}
end
# ---------------------------------------------------------------------------
# 多 Range each by orzFly
# ex: multirange_each(0..2, 1..5, 1..2) {|*a| p a}
# ---------------------------------------------------------------------------
def multirange_each(*args)
args[0].each { |i|
args.size > 1 ?
(multirange_each(*args[1, args.size - 1]) { |*v| yield(i, *v) }) :
(yield(i))
}
nil
end
# ---------------------------------------------------------------------------
# 多维数组生成
# 规则：MIN 与 MAX 尺寸相同
# size：数据尺寸
# ---------------------------------------------------------------------------
def minax_table(size)
size.each {|k,v|
@size[k] = v
@min[k] = Table.new(*v)
@max[k] = Table.new(*v)
}
end
# ---------------------------------------------------------------------------
# MIN 是否达上限（=MAX）
# 规则：是则返回 true，否则返回 false
# type：MAX 类型
# unit：MAX 单元地址
# ---------------------------------------------------------------------------
def min_full?(type,unit)
v = @size[type]
return @min[type][*v] == @max[type][*v]
end
# ---------------------------------------------------------------------------
# MIN 加载设置
# 规则：设置数组最后一个单元为设置值
# type：MIN 类型
# set：设置数据
# ---------------------------------------------------------------------------
def min_set(type,set)
set.each {|i|
@min[type][*(i[0, @size[type].size])] = i[-1]
}
end
# ---------------------------------------------------------------------------
# MAX 加载设置
# 规则：设置数组最后一个单元为设置值
# type：MIN 类型
# set：设置数据
# ---------------------------------------------------------------------------
def max_set(type,set)
set.each {|i|
@max[type][*(i[0, @size[type].size])] = i[-1]
}
end
# ---------------------------------------------------------------------------
# MIN 全部代入
# 规则：MIN 上限为 MAX
# type：MIN 类型
# value：代入的值
# ---------------------------------------------------------------------------
def min_all_cover(type,value)
multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
@min[type][*arg] = [value, @max[type][*arg]].min
}
end
# ---------------------------------------------------------------------------
# MAX 全部代入
# 规则：MAX 无限制
# type：MAX 类型
# value：代入的值
# ---------------------------------------------------------------------------
def max_all_cover(type,value)
multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
@max[type][*arg] = value
}
end
# ---------------------------------------------------------------------------
# MIN 全部增减
# 规则：MIN 下限为 0，上限为 MAX
# type：MIN 类型
# value：增加的值，负数为减
# ---------------------------------------------------------------------------
def min_all_pr(type,value)
multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
@min[type][*arg] = [0, [@min[type][*arg] + value, @max[type][*arg]].min].max
}
end
# ---------------------------------------------------------------------------
# MAX 全部增减
# 规则：MAX 无限制
# type：MAX 类型
# value：增加的值，负数为减
# ---------------------------------------------------------------------------
def max_all_pr(type,value)
multirange_each(*(@size[type].map{|i|0...i})) {|*arg|
@max[type][*arg] = @max[type][*arg] + value
}
end
# ---------------------------------------------------------------------------
# MIN 范围代入
# 规则：MIN 上限为 MAX
# type：MIN 类型
# value：代入的值
# qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
# zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
# ---------------------------------------------------------------------------
def min_range_cover(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
v = @size[type]
min = @min[type]
max = @max[type]
case v.size
when 1
zx = v[0] - zx - 1 if zx > 0
(v[0]-qx-zx).times {|x|
min[x+qx] = [value,max[x+qx]].min
}
when 2
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
min[x+qx,y+qy] = [value,max[x+qx,y+qy]].min
}
}
when 3
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
zz = v[2] - zz - 1 if zz > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
(v[2]-qz-zz).times {|z|
min[x+qx,y+qy,z+qz] = [value,max[x+qx,y+qy,z+qz]].min
}
}
}
end
end
# ---------------------------------------------------------------------------
# MAX 范围代入
# 规则：MAX 无限制
# type：MAX 类型
# value：代入的值
# qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
# zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
# ---------------------------------------------------------------------------
def max_range_cover(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
v = @size[type]
max = @max[type]
case v.size
when 1
zx = v[0] - zx - 1 if zx > 0
(v[0]-qx-zx).times {|x|
max[x+qx] = value
}
when 2
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
max[x+qx,y+qy] = value
}
}
when 3
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
zz = v[2] - zz - 1 if zz > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
(v[2]-qz-zz).times {|z|
max[x+qx,y+qy,z+qz] = value
}
}
}
end
end
# ---------------------------------------------------------------------------
# MIN 范围增减
# 规则：MIN 下限为 0，上限为 MAX
# type：MIN 类型
# value：增加的值，负数为减
# qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
# zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
# ---------------------------------------------------------------------------
def min_range_pr(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
v = @size[type]
min = @min[type]
max = @max[type]
case v.size
when 1
zx = v[0] - zx - 1 if zx > 0
(v[0]-qx-zx).times {|x|
min[x+qx] =
[0, [min[x+qx] += value, max[x+qx]].min].max
}
when 2
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
min[x+qx,y+qy] =
[0, [min[x+qx,y+qy] += value, max[x+qx,y+qy]].min].max
}
}
when 3
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
zz = v[2] - zz - 1 if zz > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
(v[2]-qz-zz).times {|z|
min[x+qx,y+qy,z+qz] =
[0, [min[x+qx,y+qy,z+qz] += value, max[x+qx,y+qy,z+qz]].min].max
}
}
}
end
end
# ---------------------------------------------------------------------------
# MAX 范围增减
# 规则：MAX 无限制
# type：MAX 类型
# value：增加的值，负数为减
# qx,qy,qz：各维范围起点，值为该维尺寸内，0为起点
# zx,zy,zz：各维范围终点，值为该维尺寸内，0为终点
# ---------------------------------------------------------------------------
def max_range_pr(type,value,qx=0,zx=0,qy=0,zy=0,qz=0,zz=0)
v = @size[type]
max = @max[type]
case v.size
when 1
zx = v[0] - zx - 1 if zx > 0
(v[0]-qx-zx).times {|x|
max[x+qx] += value
}
when 2
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
max[x+qx,y+qy] += value
}
}
when 3
zx = v[0] - zx - 1 if zx > 0
zy = v[1] - zy - 1 if zy > 0
zz = v[2] - zz - 1 if zz > 0
(v[0]-qx-zx).times {|x|
(v[1]-qy-zy).times {|y|
(v[2]-qz-zz).times {|z|
max[x+qx,y+qy,z+qz] += value
}
}
}
end
end
# ---------------------------------------------------------------------------
# MIN 单元代入
# 规则：MIN 上限为 MAX
# type：MIN 类型
# unit：MIN 单元地址
# value：增加的值，负数为减
# ---------------------------------------------------------------------------
def min_unit_cover(type,unit,value)
@min[type][*unit] = [value,@max[type][*unit]].min
end
# ---------------------------------------------------------------------------
# MAX 单元代入
# 规则：无限制
# type：MAX 类型
# unit：MAX 单元地址
# value：增加的值，负数为减
# ---------------------------------------------------------------------------
def max_unit_cover(type,unit,value)
@max[type][*unit] = value
end
# ---------------------------------------------------------------------------
# MIN 单元增减
# 规则：MIN 下限为 0，上限为 MAX
# type：MIN 类型
# unit：MIN 单元地址
# value：增加的值，负数为减
# ---------------------------------------------------------------------------
def min_unit_pr(type,unit,value)
@min[type][*unit] = [0, [@min[type][*unit] + value, @max[type][*unit][x]].min].max
end
# ---------------------------------------------------------------------------
# MAX 单元增减
# 规则：MAX 无限制
# type：MAX 类型
# unit：MAX 单元地址
# value：增加的值，负数为减
# ---------------------------------------------------------------------------
def max_unit_pr(type,unit,value)
@max[type][*unit] = @max[type][*unit] + value
end
end

复制代码