epicknex/ResearchDisorderGame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Basic Setup of files

Browse Source
This commit is contained in:
Ryan 2017-11-29 22:13:32 -05:00
parent 8538b5cd35
commit be9030a40b
124 changed files with 21289 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
game/GuiManagerDebug/Core/Clickable.int Normal file
View File

@ -0,0 +1,15 @@
function gui:Clickable()
local x,y,w,h=love.graphics.getScissor()
local mx=love.mouse.getX()
local my=love.mouse.getY()
if _GuiPro.HasStencel then
local obj=_GuiPro.StencelHolder
if self:isDescendant(obj) then
return math.sqrt((mx-obj.x)^2+(my-obj.y)^2)<=(obj.offset.size.x or 0)
end
end
if not(x) then
return true
end
return not(mx>x+w or mx<x or my>y+h or my<y)
end

1667
game/GuiManagerDebug/Core/Colors.int Normal file
View File

File diff suppressed because it is too large Load Diff

5
game/GuiManagerDebug/Core/DrawThings.int Normal file
View File

@ -0,0 +1,5 @@
function DrawThings(items)
for i=1,#items do
items[i]:draw()
end
end

85
game/GuiManagerDebug/Core/EventDefinitions.int Normal file
View File

@ -0,0 +1,85 @@
function gui:OnClicked(func)
table.insert(self.funcs,func)
end
function gui:OnReleased(func)
table.insert(self.funcs2,func)
end
function gui:OnEnter(func)
table.insert(self.funcs3,func)
end
function gui:OnExit(func)
table.insert(self.funcs4,func)
end
function gui:OnUpdate(func)
table.insert(self.funcs5,func)
end
function gui:OnDragStart(func)
table.insert(self.func8,func)
end
function gui:OnDragging(func)
table.insert(self.func6,func)
end
function gui:OnDragEnd(func)
table.insert(self.func7,func)
end
function gui:WhileHovering(func)
table.insert(self.func9,func)
end
function gui:OnMouseMoved(func)
table.insert(self.func10,func)
end
function gui:getChildren()
return self.Children
end
function gui:LClicked()
return self.lclicked
end
function gui:RClicked()
return self.rclicked
end
function gui:MClicked()
return self.mclicked
end
function gui:Clicked()
return (self.lclicked or self.rclicked)
end
function gui:Hovering()
return self.hovering
end
function gui:FreeConnections()
self.funcs={function(b,self) if b=="l" then self.LRE=true end end,function(b,self) if b=="r" then self.RRE=true end end,function(b,self) if b=="m" then self.MRE=true end end}
self.funcs2={function(b,self) if b=="l" then self.LRE=false end end,function(b,self) if b=="r" then self.RRE=false end end,function(b,self) if b=="m" then self.MRE=false end end}
self.funcs3={function(self) self.HE=true end}
self.funcs4={function(self) self.HE=false end}
self.funcs5={function(self) self.x=(self.Parent.width*self.scale.pos.x)+self.offset.pos.x+self.Parent.x self.y=(self.Parent.height*self.scale.pos.y)+self.offset.pos.y+self.Parent.y self.width=(self.Parent.width*self.scale.size.x)+self.offset.size.x self.height=(self.Parent.height*self.scale.size.y)+self.offset.size.y end}
end
function gui:LClick()
for i=1,#self.funcs do
self.funcs[i]("l",self)
end
end
function gui:RClick()
for i=1,#self.funcs do
self.funcs[i]("r",self)
end
end
function gui:MClick()
for i=1,#self.funcs do
self.funcs[i]("m",self)
end
end
function gui:LRelease()
for i=1,#self.funcs2 do
self.funcs2[i]("l",self)
end
end
function gui:RRelease()
for i=1,#self.funcs2 do
self.funcs2[i]("r",self)
end
end
function gui:MRelease()
for i=1,#self.funcs2 do
self.funcs2[i]("m",self)
end
end

46
game/GuiManagerDebug/Core/UpdateThings.int Normal file
View File

@ -0,0 +1,46 @@
function UpdateThings(items)
for i=#items,1,-1 do
if items[i]:LClicked() then
for g=1,#items[i].funcs do
items[i].funcs[g]("l",items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
elseif items[i]:RClicked() then
for g=1,#items[i].funcs do
items[i].funcs[g]("r",items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
elseif items[i]:MClicked() then
for g=1,#items[i].funcs do
items[i].funcs[g]("m",items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
end
if not(items[i]:LClicked()) and items[i].LRE then
for g=1,#items[i].funcs2 do
items[i].funcs2[g]("l",items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
elseif not(items[i]:RClicked()) and items[i].RRE then
for g=1,#items[i].funcs2 do
items[i].funcs2[g]("r",items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
elseif not(items[i]:MClicked()) and items[i].MRE then
for g=1,#items[i].funcs2 do
items[i].funcs2[g]("m",items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
end
if items[i]:Hovering() and items[i].HE==false then
for g=1,#items[i].funcs3 do
items[i].funcs3[g](items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
elseif not(items[i]:Hovering()) and items[i].HE==true then
for g=1,#items[i].funcs4 do
items[i].funcs4[g](items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
elseif items[i]:Hovering() then
for g=1,#items[i].func9 do
items[i].func9[g](items[i],love.mouse.getX()-items[i].x,love.mouse.getY()-items[i].y)
end
end
for g=1,#items[i].funcs5 do
items[i].funcs5[g](items[i])
end
end
end

25
game/GuiManagerDebug/Core/_GetAllChildren.int Normal file
View File

@ -0,0 +1,25 @@
function GetAllChildren(Object)
local Stuff = {}
function Seek(Items)
for i=1,#Items do
if Items[i].Visible==true then
table.insert(Stuff,Items[i])
local NItems = Items[i]:getChildren()
if NItems ~= nil then
Seek(NItems)
end
end
end
end
local Objs = Object:getChildren()
for i=1,#Objs do
if Objs[i].Visible==true then
table.insert(Stuff,Objs[i])
local Items = Objs[i]:getChildren()
if Items ~= nil then
Seek(Items)
end
end
end
return Stuff
end

21
game/GuiManagerDebug/Core/_GetAllChildren2.int Normal file
View File

@ -0,0 +1,21 @@
function GetAllChildren2(Object)
local Stuff = {}
function Seek(Items)
for i=1,#Items do
table.insert(Stuff,Items[i])
local NItems = Items[i]:getChildren()
if NItems ~= nil then
Seek(NItems)
end
end
end
local Objs = Object:getChildren()
for i=1,#Objs do
table.insert(Stuff,Objs[i])
local Items = Objs[i]:getChildren()
if Items ~= nil then
Seek(Items)
end
end
return Stuff
end

14
game/GuiManagerDebug/Core/eventable.int Normal file
View File

@ -0,0 +1,14 @@
function gui:eventable()
if self.important then
return true
end
if _GuiPro.Hierarchy then
if _GuiPro.TopHovered~=nil then
return self:isDescendant(_GuiPro.TopHovered) or _GuiPro.TopHovered==self
else
return true
end
else
return true
end
end

3
game/GuiManagerDebug/Core/full.int Normal file
View File

@ -0,0 +1,3 @@
function gui:full()
self:SetDualDim(nil,nil,nil,nil,nil,nil,1,1)
end

238
game/GuiManagerDebug/Core/newBase.int Normal file
View File

@ -0,0 +1,238 @@
function gui.enableAutoWindowScaling(b)
_GuiPro.DPI_ENABLED=b or true
_defaultfont=love.graphics.newFont(12*love.window.getPixelScale())
end
function filter(name, x, y, w, h, sx ,sy ,sw ,sh)
if type(name)~="string" then
sh=sw
sw=sy
sy=sx
sx=h
h=w
w=y
y=x
x=name
end
return x,y,w,h,sx,sy,sw,sh
end
function gui:newBase(tp,name, x, y, w, h, sx ,sy ,sw ,sh)
_GuiPro.count=_GuiPro.count+1
local c = {}
setmetatable(c, gui)
if self==gui then
c.Parent=_GuiPro
else
c.Parent=self
end
c.segments=nil
c.ry=nil
c.rx=nil
c.DPI=1
if _GuiPro.DPI_ENABLED then
c.DPI=love.window.getPixelScale()
x, y, w, h=c.DPI*x,c.DPI*y,c.DPI*w,c.DPI*h
end
c.centerFontY=true
c.FormFactor="rectangle"
c.Type=tp
c.Active=true
c.form="rectangle"
c.Draggable=false
c.Name=name or "Gui"..tp
c:SetName(name)
c.BorderSize=1
c.BorderColor={0,0,0}
c.BorderVisibility=1
c.VIS=true
c.Visible=true
c.oV=true
c.Children={}
c.hovering=false
c.rclicked=false
c.lclicked=false
c.mclicked=false
c.clicked=false
c.Visibility=1
c.ClipDescendants=false
c.TextWrap=true
c.scale={}
c.scale.size={}
c.scale.size.x=sw or 0
c.scale.size.y=sh or 0
c.offset={}
c.offset.size={}
c.offset.size.x=w or 0
c.offset.size.y=h or 0
c.scale.pos={}
c.scale.pos.x=sx or 0
c.scale.pos.y=sy or 0
c.offset.pos={}
c.offset.pos.x=x or 0
c.offset.pos.y=y or 0
c.width = 0
c.height = 0
c.LRE=false
c.RRE=false
c.MRE=false
c.Color = {255, 255, 255}
function c:setRoundness(rx,ry,segments)
self.segments=segments
self.ry=ry
self.rx=rx
end
function c.stfunc()
love.graphics.rectangle("fill", c.x, c.y, c.width, c.height,c.rx,c.ry,c.segments)
end
function c:hasRoundness()
return (self.ry or self.rx)
end
c.funcs={function(b,self)
if b=="l" then
self.LRE=true
end
end,
function(b,self)
if b=="r" then
self.RRE=true
end
end,
function(b,self)
if b=="m" then
self.MRE=true
end
end}
c.funcs2={function(b,self)
if b=="l" then
self.LRE=false
end
end,
function(b,self)
if b=="r" then
self.RRE=false
end
end,
function(b,self)
if b=="m" then
self.MRE=false
end
end}
c.HE=false
c.funcs3={function(self)
self.HE=true
end}
c.funcs4={function(self)
self.HE=false
end}
c.funcs5={}
c.tid={}
c.touchcount=0
c.x=(c.Parent.width*c.scale.pos.x)+c.offset.pos.x+c.Parent.x
c.y=(c.Parent.height*c.scale.pos.y)+c.offset.pos.y+c.Parent.y
c.width=(c.Parent.width*c.scale.size.x)+c.offset.size.x
c.height=(c.Parent.height*c.scale.size.y)+c.offset.size.y
c.func6={}
c.func7={function() _GuiPro.DragItem={} end}
c.func8={function(self) _GuiPro.DragItem=self end}
c.func9={}
c.func10={}
function c:ImageRule()
if self.Image then
local sx=self.width/self.ImageWidth
local sy=self.height/self.ImageHeigth
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.ImageVisibility*255)
if self.width~=self.ImageWidth and self.height~=self.ImageHeigth then
love.graphics.draw(self.Image,self.x,self.y,math.rad(self.rotation),sx,sy)
else
love.graphics.draw(self.Image,self.Quad,self.x,self.y,math.rad(self.rotation),sx,sy)
end
end
end
function c:VideoRule()
if self.Video then
local sx=self.width/self.VideoWidth
local sy=self.height/self.VideoHeigth
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.VideoVisibility*255)
if self.width~=self.VideoWidth and self.height~=self.VideoHeigth then
love.graphics.draw(self.Video,self.x,self.y,math.rad(self.rotation),sx,sy)
else
love.graphics.draw(self.Video,self.Quad,self.x,self.y,math.rad(self.rotation),sx,sy)
end
end
end
function c:repeatImage(b,b2)
if b then
self.Image:setWrap(b,b2 or "repeat")
function self:ImageRule()
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.ImageVisibility*255)
love.graphics.draw(self.Image,self.Quad,self.x,self.y,math.rad(self.rotation))
end
else
sx=self.width/self.ImageWidth
sy=self.height/self.ImageHeigth
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.ImageVisibility*255)
love.graphics.draw(self.Image,self.Quad,self.x,self.y,math.rad(self.rotation),sx,sy)
end
end
function c:Mutate(t)
for i,v in pairs(t) do
_GuiPro.self=self
if type(i)=="number" then
loadstring("_GuiPro.self:"..v)()
else
self[i]=v
end
end
return self
end
c:WhileHovering(function(self)
self.omx=self.nmx
self.omy=self.nmy
self.nmx=love.mouse.getX()
self.nmy=love.mouse.getY()
if self.omx~=self.nmx or self.omy~=self.nmy then
for i=1,#self.func10 do
if self and self.nmx and self.nmy and self.omx and self.omy then
self.func10[i](self,self.nmx,self.nmy,self.omx,self.omy)
end
end
end
if self.WasBeingDragged==true and love.mouse.isDown(self.dragbut or "m")==false and self.Type~="TextImageButtonFrameDrag" then
for i=1,#self.func7 do
self.func7[i](self,(love.mouse.getX())-self.width/2,(love.mouse.getY())-self.height/2)
end
end
if _GuiPro.hasDrag==false and love.mouse.isDown(self.dragbut or "m") then
for i=1,#self.func8 do
self.func8[i](self,(love.mouse.getX())-self.width/2,(love.mouse.getY())-self.height/2)
end
end
if self.IsBeingDragged==true then
_GuiPro.hasDrag=true
self.WasBeingDragged=true
elseif self.WasBeingDragged==true and self.IsBeingDragged==false then
self.WasBeingDragged=false
_GuiPro.hasDrag=false
end
if self.Draggable==true and love.mouse.isDown(self.dragbut or "m") and _GuiPro.hasDrag==false then
for i=1,#self.func6 do
self.func6[i](self,(love.mouse.getX())-self.width/2,(love.mouse.getY())-self.height/2)
end
_GuiPro.hasDrag=true
if self.FormFactor:lower()=="circle" or self.FormFactor:lower()=="c" or self.FormFactor:lower()=="cir" then
self.IsBeingDragged=true
x=(love.mouse.getX()-self.x)
y=(love.mouse.getY()-self.y)
self:Move(x,y)
elseif self.FormFactor:lower()=="rectangle" or self.FormFactor:lower()=="r" or self.FormFactor:lower()=="rect" then
self.IsBeingDragged=true
x=(love.mouse.getX()-self.x)-self.width/2
y=(love.mouse.getY()-self.y)-self.height/2
self:Move(x,y)
end
else
self.IsBeingDragged=false
end
end)
table.insert(c.Parent.Children,c)
return c
end

7
game/GuiManagerDebug/Core/patches.int Normal file
View File

@ -0,0 +1,7 @@
_GuiPro.mousedownfunc=love.mouse.isDown
function love.mouse.isDown(b)
if not(b) then
return false
end
return _GuiPro.mousedownfunc(({["l"]=1,["r"]=2,["m"]=3})[b] or b)
end

204
game/GuiManagerDebug/Core/touchManager.int Normal file
View File

@ -0,0 +1,204 @@
--[[WORKING ON
doubleTap - UnFinished!
touchRendering - Broken
]]
function gui:TClickable(mx,my)
local x,y,w,h=love.graphics.getScissor()
if _GuiPro.HasStencel then
local obj=_GuiPro.StencelHolder
if self:isDescendant(obj) then
return math.sqrt((mx-obj.x)^2+(my-obj.y)^2)<=(obj.offset.size.x or 0)
end
end
if not(x) then
return true
end
return not(mx>x+w or mx<x or my>y+h or my<y)
end
function gui:touchable(t)
local touches = love.touch.getTouches()
local x,y=0,0
for i, id in ipairs(touches) do
if self.id==id then
x, y = love.touch.getPosition(id)
return (x > self.x and x < self.x+self.width and y > self.y and y < self.y+self.height and self:TClickable(x,y) and self:eventable())
end
end
self.id=-1
end
multi:newTask(function() -- A bit of post-loading haha
gui.touchpressed=multi:newConnection()
gui.touchreleased=multi:newConnection()
gui.touchmoved=multi:newConnection()
love.touchpressed=Library.convert(love.touchpressed or function() end)
love.touchreleased=Library.convert(love.touchreleased or function() end)
love.touchmoved=Library.convert(love.touchmoved or function() end)
love.touchpressed:inject(function(id, x, y, dx, dy, pressure) gui.touchpressed:Fire(id, x, y, dx, dy, pressure) return {id, x, y, dx, dy, pressure} end,1)
love.touchreleased:inject(function(id, x, y, dx, dy, pressure) gui.touchreleased:Fire(id, x, y, dx, dy, pressure) return {id, x, y, dx, dy, pressure} end,1)
love.touchmoved:inject(function(id, x, y, dx, dy, pressure) gui.touchmoved:Fire(id, x, y, dx, dy, pressure) return {id, x, y, dx, dy, pressure} end,1)
_GuiPro.TouchReady=true
_GuiPro.TouchRegister={}
gui.touchpressed:connect(function(id, x, y, dx, dy, pressure)
for i,v in pairs(_GuiPro.TouchRegister) do
if #v.tid==0 then
if (x > v.x and x < v.x+v.width and y > v.y and y < v.y+v.height and v:TClickable(x,y) and v:eventable()) then
v:addTID(id)
v.touchcount=1
for i=1,#v.ToFuncP do
v.ToFuncP[i](v,id, x-v.x, y-v.y, dx, dy or 0, pressure or 1)
end
end
elseif not(v:hasTID(id)) then
if (x > v.x and x < v.x+v.width and y > v.y and y < v.y+v.height and v:TClickable(x,y) and v:eventable()) then
v:addTID(id)
v.touchcount=v.touchcount+1
for i=1,#v.ToFuncP do
v.ToFuncP[i](v,id, x-v.x, y-v.y, dx, dy or 0, pressure or 1)
end
end
end
end
end)
gui.touchreleased:connect(function(id, x, y, dx, dy, pressure)
for i,v in pairs(_GuiPro.TouchRegister) do
if v:hasTID(id) then
v:removeTID(id)
for i=1,#v.ToFuncR do
v.ToFuncR[i](v,id, x-v.x, y-v.y, dx, dy or 0, pressure or 1)
end
end
end
end)
gui.touchmoved:connect(function(id, x, y, dx, dy, pressure)
for i,v in pairs(_GuiPro.TouchRegister) do
if v:hasTID(id) and (x > v.x and x < v.x+v.width and y > v.y and y < v.y+v.height and v:TClickable(x,y) and v:eventable()) then
for i=1,#v.ToFuncM do
v.ToFuncM[i](v,id, x-v.x, y-v.y, dx, dy or 0, pressure or 1)
end
elseif v:hasTID(id) and not((x > v.x and x < v.x+v.width and y > v.y and y < v.y+v.height and v:TClickable(x,y) and v:eventable())) then
v:removeTID(id)
for i=1,#v.ToFuncR do
v.ToFuncR[i](v,id, x-v.x, y-v.y, dx, dy or 0, pressure or 1)
end
end
end
end)
end)
-- now that that is done lets set up some more post loading checks
_GuiPro.int=multi:newProcess()
_GuiPro.int:Start()
_GuiPro.int:setJobSpeed(.001)
_GuiPro.EXACT=0
_GuiPro.LAX=.01
_GuiPro.LAZY=.05
-- now lets define the reg function
function gui.Compare(a,b,v,tp)
if tp==">" then
if (a+v>b or a-v>b) then
return true
end
elseif tp=="<" then
if (a+v<b or a-v<b) then
return true
end
elseif tp=="<=" then
if (a+v<=b or a-v<=b) then
return true
end
elseif tp==">=" then
if (a+v>=b or a-v>=b) then
return true
end
elseif tp=="==" then -- this one is gonna be tricky
if (a>=b-v and a<=b+v) or (b>=a-v and b<=a+v) then
return true
end
end
return false
end
function gui:regesterTouch()
local obj=self
obj.ToFuncP={}
obj.ToFuncM={}
obj.ToFuncR={}
obj.To2Func={}
obj.ToDTFunc={}
obj.touchRendering =_GuiPro.EXACT -- exact(0), lax(), #
function obj:removeTID(id)
for i=1,#self.tid do
if self.tid[i]==id then
table.remove(self.tid,i)
self.touchcount=self.touchcount-1
return
end
end
end
function obj:hasTID(id)
for i=1,#self.tid do
if self.tid[i]==id then
return true
end
end
return false
end
obj.txl1=0
obj.tyl1=0
obj.txl2=0
obj.tyl2=0
obj.LS=0
obj:OnUpdate(function(self)
if self.touchcount==2 then
local x1,y1=love.touch.getPosition( self.tid[1] )
local x2,y2=love.touch.getPosition( self.tid[2] )
local CS=math.sqrt((x2-x1)^2+(y2-y1)^2)
if gui.Compare(CS,self.LS,self.touchRendering,">") then
for i=1,#self.To2Func do
self.To2Func[i](self,CS,x1-self.x,y1-self.y,x2-self.x,y2-self.y)
end
elseif gui.Compare(CS,self.LS,self.touchRendering,"<") then
for i=1,#self.To2Func do
self.To2Func[i](self,-CS,x1-self.x,y1-self.y,x2-self.x,y2-self.y)
end
elseif gui.Compare(CS,self.LS,self.touchRendering,"==") then
for i=1,#self.To2Func do
self.To2Func[i](self,0,x1-self.x,y1-self.y,x2-self.x,y2-self.y)
end
end
-- if self.txl1~=x1 or self.txl2~=x2 or self.tyl1~=y1 or self.tyl2~=y2 then
-- for i=1,#self.To2Func do
-- self.To2Func[i](self,0,x1-self.x,y1-self.y,x2-self.x,y2-self.y)
-- end
-- end
self.LS=CS
self.txl1=x1
self.txl2=x2
self.tyl1=y1
self.tyl2=y2
end
end)
function obj:OnDoubleTap(func)
table.insert(self.ToDTFunc,func)
end
function obj:On2TouchMoved(func)
table.insert(self.To2Func,func)
end
function obj:addTID(id)
table.insert(self.tid,id)
end
function obj:OnTouchPressed(func)
table.insert(self.ToFuncP,func) -- event for touches
end
function obj:OnTouchReleased(func) -- event for touches
table.insert(self.ToFuncR,func)
end
function obj:OnTouchMoved(func) -- event for touches
table.insert(self.ToFuncM,func)
end
if _GuiPro.TouchReady then -- my sneaky test
print("Registred: "..tostring(obj))
table.insert(_GuiPro.TouchRegister,obj)
else
print("Attempting to register: "..tostring(obj))
_GuiPro.int:newJob(function() table.insert(_GuiPro.TouchRegister,obj) end) -- a sneaky way to ensure that your object gets registered eventually, even if you call the method before the touch patch was activated.
end
end

4
game/GuiManagerDebug/Drawing/AddDrawRuleB.int Normal file
View File

@ -0,0 +1,4 @@
function gui:AddDrawRuleB(rule)
if not(self.DrawRulesB) then self.DrawRulesB={} end
table.insert(self.DrawRulesB,rule)
end

4
game/GuiManagerDebug/Drawing/AddDrawRuleE.int Normal file
View File

@ -0,0 +1,4 @@
function gui:AddDrawRuleE(rule)
if not(self.DrawRulesE) then self.DrawRulesE={} end
table.insert(self.DrawRulesE,rule)
end

12
game/GuiManagerDebug/Drawing/draw.int Normal file
View File

@ -0,0 +1,12 @@
function gui:draw()
if _GuiPro.rotate~=0 then
love.graphics.rotate(math.rad(_GuiPro.rotate))
end
if self.FormFactor:lower()=="rectangle" then
self:drawR()
elseif self.FormFactor:lower()=="circle" then
self:drawC()
else
error("Unsupported FormFactor: "..self.FormFactor.."!")
end
end

89
game/GuiManagerDebug/Drawing/drawC.int Normal file
View File

@ -0,0 +1,89 @@
function gui:drawC()
if love.mouse.isDown("l")==false and love.mouse.isDown("m")==false and love.mouse.isDown("r")==false then
_GuiPro.DragItem={}
_GuiPro.hasDrag=false
end
if self.Visible==true and self.VIS==true then
local b=true
for i,v in pairs(_GuiPro.Clips) do
if self:isDescendant(v)==true then
b=false
end
end
if b then
love.graphics.setStencilTest( )
_GuiPro.HasStencel=false
_GuiPro.StencelHolder=nil
end
local x,y,r,s=(self.offset.pos.x or 0)+self.Parent.x,(self.offset.pos.y or 0)+self.Parent.y,self.offset.size.x or 0,self.offset.size.y or 360
if self.CC then
x,y=x+r,y+r
end
self.x,self.y=x,y
_GuiPro.circleStencilFunction = function()
love.graphics.circle("fill",x,y,r,s)
end
if math.sqrt((love.mouse.getX()-x)^2+(love.mouse.getY()-y)^2)<=r and self:eventable() and self:Clickable() and self.Active==true then
self.hovering=true
if love.mouse.isDown("l") and _GuiPro.hasDrag==false then
if string.find(self.Type, "Button") then
love.graphics.setColor(self.Color[1]-10, self.Color[2]-10, self.Color[3]-10,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.lclicked=true
elseif love.mouse.isDown("r") and _GuiPro.hasDrag==false then
if string.find(self.Type, "Button") then
love.graphics.setColor(self.Color[1]-10, self.Color[2]-10, self.Color[3]-10,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.rclicked=true
elseif love.mouse.isDown("m") and _GuiPro.hasDrag==false then
if string.find(self.Type, "Button") then
love.graphics.setColor(self.Color[1]-10, self.Color[2]-10, self.Color[3]-10,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.mclicked=true
else
if string.find(self.Type, "Button") and _GuiPro.hasDrag==false then
love.graphics.setColor(self.Color[1]-5, self.Color[2]-5, self.Color[3]-5,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.rclicked=false
self.lclicked=false
self.mclicked=false
end
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
self.hovering=false
self.rclicked=false
self.lclicked=false
self.mclicked=false
end
if self.ClipDescendants==true then
_GuiPro.Clips[tostring(self)]=self
_GuiPro.HasStencel=true
_GuiPro.StencelHolder=self
love.graphics.stencil(_GuiPro.circleStencilFunction)
love.graphics.setStencilTest("notequal",0)
end
love.graphics.circle("fill",x,y,r,s)
love.graphics.setColor(self.BorderColor[1], self.BorderColor[2], self.BorderColor[3],self.BorderVisibility*254)
for b=0,self.BorderSize-1 do
love.graphics.circle("line",x,y,r+b,s)
end
if string.find(self.Type, "Text") then
if self.text~=nil then
if self.AutoScaleText then
self.FontSize=math.floor(self.height/1.45833)
end
love.graphics.setColor(self.TextColor[1],self.TextColor[2],self.TextColor[3],self.TextVisibility*254)
love.graphics.setFont(self.Font)
love.graphics.printf(self.text, x-(r/2)+(self.XTween), y-(r/2)+self.Tween, r, self.TextFormat)
end
end
end
end

118
game/GuiManagerDebug/Drawing/drawR.int Normal file
View File

@ -0,0 +1,118 @@
function gui:drawR()
if love.mouse.isDown("l")==false and love.mouse.isDown("m")==false and love.mouse.isDown("r")==false then
_GuiPro.DragItem={}
_GuiPro.hasDrag=false
end
if self.Visible==true and self.VIS==true then
local b=true
for i,v in pairs(_GuiPro.Clips) do
if self:isDescendant(v)==true then
b=false
end
end
if b==true then
love.graphics.setStencilTest()
love.graphics.setScissor()
end
self.x=(self.Parent.width*self.scale.pos.x)+self.offset.pos.x+self.Parent.x
self.y=(self.Parent.height*self.scale.pos.y)+self.offset.pos.y+self.Parent.y
self.width=(self.Parent.width*self.scale.size.x)+self.offset.size.x
self.height=(self.Parent.height*self.scale.size.y)+self.offset.size.y
if self.DrawRulesB then
for dr=1,#self.DrawRulesB do
self.DrawRulesB[dr](self)
end
end
if (love.mouse.getX() > self.x and love.mouse.getX() < self.x+self.width and love.mouse.getY() > self.y and love.mouse.getY() < self.y+self.height and self:Clickable() and self:eventable()) or self:touchable("r") and self.Active==true then
self.hovering=true
if love.mouse.isDown("l") or self:touchable("r") and _GuiPro.hasDrag==false then
if string.find(self.Type, "Button") then
love.graphics.setColor(self.Color[1]-10, self.Color[2]-10, self.Color[3]-10,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.lclicked=true
elseif love.mouse.isDown("r") or self:touchable("r") and _GuiPro.hasDrag==false then
if string.find(self.Type, "Button") then
love.graphics.setColor(self.Color[1]-10, self.Color[2]-10, self.Color[3]-10,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.rclicked=true
elseif love.mouse.isDown("m") or self:touchable("r") and _GuiPro.hasDrag==false then
if string.find(self.Type, "Button") then
love.graphics.setColor(self.Color[1]-10, self.Color[2]-10, self.Color[3]-10,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.mclicked=true
else
if string.find(self.Type, "Button") or self:touchable("r") and _GuiPro.hasDrag==false then
love.graphics.setColor(self.Color[1]-5, self.Color[2]-5, self.Color[3]-5,self.Visibility*254)
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
end
self.rclicked=false
self.lclicked=false
self.mclicked=false
end
else
love.graphics.setColor(self.Color[1],self.Color[2],self.Color[3],self.Visibility*254)
self.hovering=false
self.rclicked=false
self.lclicked=false
self.mclicked=false
end
if self.ClipDescendants==true then
_GuiPro.Clips[tostring(self)]=self
love.graphics.setScissor(self.x, self.y, self.width, self.height)
end
if self:hasRoundness() then
love.graphics.stencil(self.stfunc, "replace", 1)
love.graphics.setStencilTest("greater", 0)
end
love.graphics.rectangle("fill", self.x, self.y, self.width, self.height,(self.rx or 1)*self.DPI,(self.ry or 1)*self.DPI,(self.segments or 1)*self.DPI)
if string.find(self.Type, "Image") then
self:ImageRule()
end
if self.Type=="Video" then
self:VideoRule()
end
if self:hasRoundness() then
love.graphics.setStencilTest()
end
love.graphics.setColor(self.BorderColor[1], self.BorderColor[2], self.BorderColor[3],self.BorderVisibility*254)
for b=0,self.BorderSize-1 do
love.graphics.rectangle("line", self.x-(b/2), self.y-(b/2), self.width+b, self.height+b,(self.rx or 1)*self.DPI,(self.ry or 1)*self.DPI,(self.segments or 1)*self.DPI)
end
if string.find(self.Type, "Text") then
if self.text~=nil then
if self.AutoScaleText then
self.FontSize=math.floor(self.height/1.45833)
end
love.graphics.setColor(self.TextColor[1],self.TextColor[2],self.TextColor[3],self.TextVisibility*254)
if self.Font==_defaultfont then
love.graphics.setFont(self.Font)
love.graphics.printf(self.text, self.x+2+(self.XTween*self.DPI)+((self.marginL or 0)*self.DPI or self.XTween*self.DPI), self.y+(self.FontHeight/2)+self.Tween*self.DPI, self.width+(0 or (self.marginR or 0)*self.DPI), self.TextFormat)
else
if type(self.Font)=="string" then
self.Font=love.graphics.newFont(self.Font,self.FontSize)
self.FontHeight=self.Font:getHeight()
else
love.graphics.setFont(self.Font)
end
if type(self.FontSize)=="string" then
self.FontSize=tonumber(self.FontSize)
love.graphics.setNewFont(self.FontSize)
end
love.graphics.printf(self.text, self.x+2+((self.marginL or 0)*self.DPI or self.XTween*self.DPI), self.y+math.floor((self.FontHeight-self.FontSize)/2)+self.Tween*self.DPI, self.width+(0 or (self.marginR or 0)*self.DPI), self.TextFormat)
end
end
end
if self.DrawRulesE then
for dr=1,#self.DrawRulesE do
self.DrawRulesE[dr](self)
end
end
end
end

37
game/GuiManagerDebug/Frame/newDropFrame.int Normal file
View File

@ -0,0 +1,37 @@
function gui:newDropFrame(name,x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("DropFrame",name, x, y, w, h, sx ,sy ,sw ,sh)
c.WasBeingDragged=false
c.IsBeingDragged=false
c.Draggable=false
c.funcD={}
function c:GetDroppedItems()
local t=self:getChildren()
local tab={}
for i=1,#t do
if t[i].Type=="TextImageButtonFrameDrag" then
table.insert(tab,t[i])
end
end
return tab
end
function c:OnDropped(func)
table.insert(self.funcD,func)
end
c:OnUpdate(function(self)
if _GuiPro.DragItem then
if _GuiPro.DragItem.Type=="TextImageButtonFrameDrag" and love.mouse.isDown(_GuiPro.DragItem.dragbut or "m")==false and self:IsHovering() then
local t=_GuiPro.DragItem
_GuiPro.DragItem={}
for i=1,#t.funcD do
t.funcD[i](self,t)
end
for i=1,#self.funcD do
self.funcD[i](self,t)
end
_GuiPro.hasDrag=false
end
end
end)
return c
end

8
game/GuiManagerDebug/Frame/newFrame.int Normal file
View File

@ -0,0 +1,8 @@
function gui:newFrame(name,x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("Frame",name, x, y, w, h, sx ,sy ,sw ,sh)
c.WasBeingDragged=false
c.IsBeingDragged=false
c.Draggable=false
return c
end

4
game/GuiManagerDebug/Frame/newFullFrame.int Normal file
View File

@ -0,0 +1,4 @@
function gui:newFullFrame(name)
name=name or ""
return self:newFrame(name,0,0,0,0,0,0,1,1)
end

59
game/GuiManagerDebug/Frame/newTabFrame.int Normal file
View File

@ -0,0 +1,59 @@
function gui:newTabFrame(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=gui:newFrame(name, x, y, w, h, sx ,sy ,sw ,sh)
c.tabheight=20
c.Holder=c:newFrame("Holder",0,c.tabheight,0,0,0,0,1,1)
c.TabHolder=c:newFrame("TabHolder",0,0,0,c.tabheight,0,0,1)
function c:setTabHeight(n)
self.tabheight=n
self.Holder:SetDualDim(0,-self.tabheight,0,0,0,0,1,1)
end
function c:addTab(name,colorT,colorH)
if colorT and not(colorH) then
colorH=colorT
end
local tab=self.TabHolder:newTextButton(name,name,0,0,0,0,0,0,0,1)
tab.Tween=-3
if colorT then
tab.Color=colorT
end
local holder=self.Holder:newFrame(name,0,0,0,0,0,0,1,1)
if colorH then
holder.Color=colorH
end
tab.frame=holder
tab:OnReleased(function(b,self)
if b=="l" then
local tt=self.Parent:getChildren()
local th=self.Parent.Parent.Holder:getChildren()
for i=1,#th do
th[i].Visible=false
end
for i=1,#tt do
tt[i].frame.Visible=false
tt[i].BorderSize=1
end
self.BorderSize=0
self.frame.Visible=true
end
end)
local tt=self.TabHolder:getChildren()
for i=1,#tt do
tt[i].frame.Visible=false
tt[i].BorderSize=1
end
tab.frame.Visible=true
tab.BorderSize=0
return tab,holder
end
c:OnUpdate(function(self)
local th=self.TabHolder:getChildren()
local l=self.width/#th
for i=1,#th do
th[i]:SetDualDim(l*(i-1),0,l)
end
if #th==0 then
self:Destroy()
end
end)
return c
end

0
game/GuiManagerDebug/Frame/newratioFrame.int Normal file
View File

13
game/GuiManagerDebug/Image-Animation/SetImage.int Normal file
View File

@ -0,0 +1,13 @@
function gui:SetImage(i)
if type(i)=="string" then
self.Image=love.graphics.newImage(i)
else
self.Image=i
end
if self.Image~=nil then
self.ImageHeigth=self.Image:getHeight()
self.ImageWidth=self.Image:getWidth()
self.Quad=love.graphics.newQuad(0,0,self.width,self.height,self.ImageWidth,self.ImageHeigth)
end
return self.ImageWidth,self.ImageHeigth
end

5
game/GuiManagerDebug/Image-Animation/UpdateImage.int Normal file
View File

@ -0,0 +1,5 @@
function gui:UpdateImage()
self.ImageHeigth=self.Image:getHeight()
self.ImageWidth=self.Image:getWidth()
self.Quad=love.graphics.newQuad(0,0,self.width,self.height,self.ImageWidth,self.ImageHeigth)
end

20
game/GuiManagerDebug/Image-Animation/getTile.int Normal file
View File

@ -0,0 +1,20 @@
function gui:getTile(i,x,y,w,h)-- returns imagedata
if type(i)=="string" then
i=love.graphics.newImage(i)
elseif type(i)=="userdata" then
-- do nothing
elseif string.find(self.Type,"Image",1,true) then
local i,x,y,w,h=self.Image,i,x,y,w
else
error("getTile invalid args!!! Usage: ImageElement:getTile(x,y,w,h) or gui:getTile(imagedata,x,y,w,h)")
end
local iw,ih=i:getDimensions()
local id,_id=i:getData(),love.image.newImageData(w,h)
for _x=x,w+x-1 do
for _y=y,h+y-1 do
--
_id:setPixel(_x-x,_y-y,id:getPixel(_x,_y))
end
end
return love.graphics.newImage(_id)
end

57
game/GuiManagerDebug/Image-Animation/newAnim.int Normal file
View File

@ -0,0 +1,57 @@
function gui:newAnim(file,delay, x, y, w, h, sx ,sy ,sw ,sh)
local x,y,w,h,sx,sy,sw,sh=filter(file, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("ImageAnimation",file, x, y, w, h, sx ,sy ,sw ,sh)
c.Visibility=0
c.ImageVisibility=1
c.delay=delay or .05
c.files={}
c.AnimStart={}
c.AnimEnd={}
local _files=alphanumsort(love.filesystem.getDirectoryItems(file))
for i=1,#_files do
if string.sub(_files[i],-1,-1)~="b" then
table.insert(c.files,love.graphics.newImage(file.."/".._files[i]))
end
end
c.step=multi:newTStep(1,#c.files,1,c.delay)
c.step.parent=c
c.rotation=0
c.step:OnStart(function(step)
for i=1,#step.parent.AnimStart do
step.parent.AnimStart[i](step.parent)
end
end)
c.step:OnStep(function(pos,step)
step.parent:SetImage(step.parent.files[pos])
end)
c.step:OnEnd(function(step)
for i=1,#step.parent.AnimEnd do
step.parent.AnimEnd[i](step.parent)
end
end)
function c:OnAnimStart(func)
table.insert(self.AnimStart,func)
end
function c:OnAnimEnd(func)
table.insert(self.AnimEnd,func)
end
function c:Pause()
self.step:Pause()
end
function c:Resume()
self.step:Resume()
end
function c:Reset()
self.step.pos=1
end
function c:getFrames()
return #self.files
end
function c:getFrame()
return self.step.pos
end
function c:setFrame(n)
return self:SetImage(self.files[n])
end
return c
end

52
game/GuiManagerDebug/Image-Animation/newAnimFromData.int Normal file
View File

@ -0,0 +1,52 @@
function gui:newAnimFromData(data,delay, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("ImageAnimation","FromFile", x, y, w, h, sx ,sy ,sw ,sh)
c.Visibility=0
c.ImageVisibility=1
c.delay=delay or .05
c.files=data
c.AnimStart={}
c.AnimEnd={}
c:SetImage(c.files[1])
c.step=multi:newTStep(1,#c.files,1,c.delay)
c.step.parent=c
c.rotation=0
c.step:OnStart(function(step)
for i=1,#step.parent.AnimStart do
step.parent.AnimStart[i](step.parent)
end
end)
c.step:OnStep(function(pos,step)
step.parent:SetImage(step.parent.files[pos])
end)
c.step:OnEnd(function(step)
for i=1,#step.parent.AnimEnd do
step.parent.AnimEnd[i](step.parent)
end
end)
function c:OnAnimStart(func)
table.insert(self.AnimStart,func)
end
function c:OnAnimEnd(func)
table.insert(self.AnimEnd,func)
end
function c:Pause()
self.step:Pause()
end
function c:Resume()
self.step:Resume()
end
function c:Reset()
self.step.pos=1
end
function c:getFrames()
return #self.files
end
function c:getFrame()
return self.step.pos
end
function c:setFrame(n)
return self:SetImage(self.files[n])
end
return c
end

59
game/GuiManagerDebug/Image-Animation/newAnimFromTiles.int Normal file
View File

@ -0,0 +1,59 @@
function gui:newAnimFromTiles(file,xd,yd,delay, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(file, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("ImageAnimation",file, x, y, w, h, sx ,sy ,sw ,sh)
local im=love.graphics.newImage(file)
local _x,_y=im:getDimensions()
c.Visibility=0
c.ImageVisibility=1
c.delay=delay or .05
c.files={}
c.AnimStart={}
c.AnimEnd={}
for i=0,_y/yd-1 do
for j=0,_x/xd-1 do
table.insert(c.files,gui:getTile(im,j*xd,i*yd,xd,yd))
end
end
c:SetImage(c.files[1])
c.step=multi:newTStep(1,#c.files,1,c.delay)
c.step.parent=c
c.rotation=0
c.step:OnStart(function(step)
for i=1,#step.parent.AnimStart do
step.parent.AnimStart[i](step.parent)
end
end)
c.step:OnStep(function(pos,step)
step.parent:SetImage(step.parent.files[pos])
end)
c.step:OnEnd(function(step)
for i=1,#step.parent.AnimEnd do
step.parent.AnimEnd[i](step.parent)
end
end)
function c:OnAnimStart(func)
table.insert(self.AnimStart,func)
end
function c:OnAnimEnd(func)
table.insert(self.AnimEnd,func)
end
function c:Pause()
self.step:Pause()
end
function c:Resume()
self.step:Resume()
end
function c:Reset()
self.step.pos=1
end
function c:getFrames()
return #self.files
end
function c:getFrame()
return self.step.pos
end
function c:setFrame(n)
return self:SetImage(self.files[n])
end
return c
end

3
game/GuiManagerDebug/Image-Animation/newFullImageLabel.int Normal file
View File

@ -0,0 +1,3 @@
function gui:newFullImageLabel(i,name)
return self:newImageLabel(i,name,0,0,0,0,0,0,1,1)
end

25
game/GuiManagerDebug/Image-Animation/newImageButton.int Normal file
View File

@ -0,0 +1,25 @@
function gui:newImageButton(i,name, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("ImageButton",name, x, y, w, h, sx ,sy ,sw ,sh)
if type(i)=="string" then
c.Image=love.graphics.newImage(i)
else
c.Image=i
end
c.Visibility=0
c.ImageVisibility=1
c.rotation=0
if c.Image~=nil then
c.ImageHeigth=c.Image:getHeight()
c.ImageHeight=c.Image:getHeight()
c.ImageWidth=c.Image:getWidth()
c.Quad=love.graphics.newQuad(0,0,w,h,c.ImageWidth,c.ImageHeigth)
end
c:OnEnter(function()
love.mouse.setCursor(_GuiPro.CursorH)
end)
c:OnExit(function()
love.mouse.setCursor(_GuiPro.CursorN)
end)
return c
end

18
game/GuiManagerDebug/Image-Animation/newImageLabel.int Normal file
View File

@ -0,0 +1,18 @@
function gui:newImageLabel(i,name, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("ImageLabel",name, x, y, w, h, sx ,sy ,sw ,sh)
if type(i)=="string" then
c.Image=love.graphics.newImage(i)
else
c.Image=i
end
c.Visibility=0
c.ImageVisibility=1
c.rotation=0
if c.Image~=nil then
c.ImageHeigth=c.Image:getHeight()
c.ImageWidth=c.Image:getWidth()
c.Quad=love.graphics.newQuad(0,0,w,h,c.ImageWidth,c.ImageHeigth)
end
return c
end

62
game/GuiManagerDebug/Image-Animation/newVideo.int Normal file
View File

@ -0,0 +1,62 @@
function gui:newVideo(name,i,x,y,w,h,sx,sy,sw,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("Video",name, x, y, w, h, sx ,sy ,sw ,sh)
if type(i)=="string" then
c.Video=love.graphics.newVideo(i)
else
c.Video=i
end
c.Visibility=0
c.VideoVisibility=1
c.rotation=0
if c.Video~=nil then
c.VideoHeigth=c.Video:getHeight()
c.VideoWidth=c.Video:getWidth()
c.Quad=love.graphics.newQuad(0,0,w,h,c.VideoWidth,c.VideoHeigth)
end
c.funcV={}
function c:Play()
self.handStart=true
self.Video:play()
end
function c:Pause()
self.Video:pause()
end
c.Resume=c.Play
function c:Stop()
self.handStart=false
self:Pause()
self:Rewind()
for i=1,# self.funcV do
self.funcV[i](self)
end
end
function c:OnVideoStopped(func)
table.insert(self.funcV,func)
end
function c:Rewind()
self.Video:rewind()
end
function c:Restart()
self:Rewind()
self:Play()
end
function c:Seek(o)
self.Video:seek(o)
end
function c:Tell()
self.Video:tell()
end
function c:SetFilter(min, mag, anisotropy)
self.Video:setFilter(min, mag, anisotropy)
end
function c:IsPlaying()
return self.Video:isPlaying()
end
c:OnUpdate(function(self)
if self.Video:isPlaying()==false and self.handStart == true then
self:Stop()
end
end)
return c
end

51
game/GuiManagerDebug/Item/newDragItem.int Normal file
View File

@ -0,0 +1,51 @@
function gui:newDragItem(t,i,name, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("TextImageButtonFrameDrag",name, x, y, w, h, sx ,sy ,sw ,sh)
c.WasBeingDragged=false
c.IsBeingDragged=false
c.Draggable=true
c.funcD={}
if type(i)=="string" then
c.Image=love.graphics.newImage(i)
c.ImageVisibility=1
c.ImageHeigth=c.Image:getHeight()
c.ImageWidth=c.Image:getWidth()
c.Quad=love.graphics.newQuad(0,0,w,h,c.ImageWidth,c.ImageHeigth)
elseif type(i)=="image" then
c.Image=i
c.ImageVisibility=1
c.ImageHeigth=c.Image:getHeight()
c.ImageWidth=c.Image:getWidth()
c.Quad=love.graphics.newQuad(0,0,w,h,c.ImageWidth,c.ImageHeigth)
end
c:OnDragStart(function(self,x,y)
if _GuiPro.hasDrag==false then
self:setParent(_GuiPro)
self:SetDualDim(x,y)
self:TopStack()
end
end)
c.rotation=0
c.Tween=0
c.XTween=0
c.text = t
c.AutoScaleText=false
c.FontHeight=_defaultfont:getHeight()
c.Font=_defaultfont
c.FontSize=15
c.TextFormat="center"
c.TextVisibility=1
c.TextColor = {0, 0, 0}
function c:OnDropped(func)
table.insert(self.funcD,func)
end
c:OnUpdate(function(self)
if love.mouse.isDown("m" or self.dragbut)==false and self==_GuiPro.DragItem and self.hovering==false then
_GuiPro.DragItem={}
for i=1,#self.func7 do
self.func7[i](self,(love.mouse.getX())-self.width/2,(love.mouse.getY())-self.height/2)
end
end
end)
return c
end

28
game/GuiManagerDebug/Item/newItem.int Normal file
View File

@ -0,0 +1,28 @@
function gui:newItem(t,i,name, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("TextImageButtonFrame",name, x, y, w, h, sx ,sy ,sw ,sh)
if type(i)=="string" then
c.Image=love.graphics.newImage(i)
else
c.Image=i
end
c.rotation=0
c.ImageVisibility=1
c.Draggable=false
if c.Image~=nil then
c.ImageHeigth=c.Image:getHeight()
c.ImageWidth=c.Image:getWidth()
c.Quad=love.graphics.newQuad(0,0,w,h,c.ImageWidth,c.ImageHeigth)
end
c.Tween=0
c.XTween=0
c.text = t
c.AutoScaleText=false
c.FontHeight=_defaultfont:getHeight()
c.Font=_defaultfont
c.FontSize=15
c.TextFormat="center"
c.TextVisibility=1 -- 0=invisible,1=solid (self.TextVisibility*254+1)
c.TextColor = {0, 0, 0}
return c
end

45
game/GuiManagerDebug/Misc/AdvTextBox.int Normal file
View File

@ -0,0 +1,45 @@
function gui:AdvTextBox(txt,x,y,w,h,sx,sy,sw,sh)
name="AdvTextBox"
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("AdvTextBoxFrame",name, x, y, w, 30, sx ,sy ,sw ,sh)
c.Draggable=true
c.dragbut="r"
c.BorderSize=0
c:ApplyGradient{Color.Blue,Color.sexy_purple}
c:newTextLabel(txt,"Holder",0,0,0,h-30,0,1,1,0).Color=Color.sexy_purple
c.funcO={}
c.funcX={}
c:OnDragStart(function(self)
self:TopStack()
end)
--local temp = c:newTextButton("X","Close",-25,5,20,20,1)
--temp.Tween=-5
--temp.XTween=-2
--temp:OnReleased(function(b,self) for i=1,#self.Parent.funcX do self.Parent.funcX[i](self.Parent) end end)
--temp.Color=Color.Red
c.tLink=c:newTextBox("puttext","TextBox",5,h-95,-40,30,0,1,1,1)
c.tLink.Color=Color.light_gray
c.tLink.ClearOnFocus=true
c.tLink:OnFocus(function(self) self.ClearOnFocus=false end)
local temp=c:newTextButton("OK","Ok",-35,h-65,30,30,1,1)
temp:OnReleased(function(b,self) for i=1,#self.Parent.funcO do self.Parent.funcO[i](self.Parent,self.Parent.tLink.text) end end)
temp.Color=Color.Green
temp.XTween=-2
local temp=c:newTextButton("X","Cancel",-35,h-95,30,30,1,1)
temp:OnReleased(function(b,self) for i=1,#self.Parent.funcX do self.Parent.funcX[i](self.Parent,self.Parent.tLink.text) end end)
temp.Color=Color.Red
temp.XTween=-2
function c:Close()
self.Visible=false
end
function c:Open()
self.Visible=true
end
function c:OnOk(func)
table.insert(self.funcO,func)
end
function c:OnX(func)
table.insert(self.funcX,func)
end
return c
end

36
game/GuiManagerDebug/Misc/ApplyGradient.int Normal file
View File

@ -0,0 +1,36 @@
function _GuiPro.gradient(colors)
local direction = colors.direction or "horizontal"
colors.direction=nil
trans = colors.trans or 255
trans=math.floor(trans)
if direction == "horizontal" then
direction = true
elseif direction == "vertical" then
direction = false
else
error("Invalid direction '" .. tostring(direction) "' for gradient. Horizontal or vertical expected.")
end
local result = love.image.newImageData(direction and 1 or #colors, direction and #colors or 1)
for __i, color in ipairs(colors) do
local x, y
if direction then
x, y = 0, __i - 1
else
x, y = __i - 1, 0
end
result:setPixel(x, y, color[1], color[2], color[3], trans)
end
result = love.graphics.newImage(result)
result:setFilter('linear', 'linear')
return result
end
function _GuiPro.drawinrect(img, x, y, w, h, r, ox, oy, kx, ky)
love.graphics.draw(img, x, y, r, w / img:getWidth(), h / img:getHeight(), ox, oy, kx, ky)
end
function gui:ApplyGradient(rules)
self.Image=nil
self.Type=self.Type.."w/GradImage"
self.rotation=0
self.ImageVisibility=rules.visibility or 1
self:SetImage(_GuiPro.gradient(rules))
end

10
game/GuiManagerDebug/Misc/BottomStack.int Normal file
View File

@ -0,0 +1,10 @@
function gui:BottomStack()
childs=self.Parent:getChildren()
for i=1,#childs do
if childs[i]==self then
table.remove(self.Parent.Children,i)
table.insert(self.Parent.Children,1,self)
break
end
end
end

4
game/GuiManagerDebug/Misc/Center.int Normal file
View File

@ -0,0 +1,4 @@
function gui:Center()
local x,y=self:getFullSize()
self:SetDualDim(-math.floor(x/2),-math.floor(y/2),nil,nil,.5,.5)
end

9
game/GuiManagerDebug/Misc/Destroy.int Normal file
View File

@ -0,0 +1,9 @@
function gui:Destroy()
check=self.Parent:getChildren()
local cc=0
for cc=1,#check do
if check[cc]==self then
table.remove(self.Parent.Children,cc)
end
end
end

25
game/GuiManagerDebug/Misc/GetAllChildren.int Normal file
View File

@ -0,0 +1,25 @@
function gui:GetAllChildren()
local Stuff = {}
function Seek(Items)
for i=1,#Items do
if Items[i].Visible==true then
table.insert(Stuff,Items[i])
local NItems = Items[i]:getChildren()
if NItems ~= nil then
Seek(NItems)
end
end
end
end
local Objs = self:getChildren()
for i=1,#Objs do
if Objs[i].Visible==true then
table.insert(Stuff,Objs[i])
local Items = Objs[i]:getChildren()
if Items ~= nil then
Seek(Items)
end
end
end
return Stuff
end

3
game/GuiManagerDebug/Misc/GetChild.int Normal file
View File

@ -0,0 +1,3 @@
function gui:GetChild(name)
return self.Children[name] or self
end

3
game/GuiManagerDebug/Misc/InGrid.int Normal file
View File

@ -0,0 +1,3 @@
function InGrid(i,x,y,s)
return math.floor((i-1)/x)*s,(i-1)*s-(math.floor((i-1)/y)*(s*x))
end

5
game/GuiManagerDebug/Misc/InGridX.int Normal file
View File

@ -0,0 +1,5 @@
function InGridX(i,w,h,xs,ys)
local xc,yc=math.floor(w/xs),math.floor(h/ys)
local xi,yi=(i-1)%xc,math.floor((i-1)/xc)
return xi*xs,yi*ys
end

5
game/GuiManagerDebug/Misc/InGridY.int Normal file
View File

@ -0,0 +1,5 @@
function InGridY(i,w,h,xs,ys)
local xc,yc=math.floor(w/xs),math.floor(h/ys)
local xi,yi=math.floor((i-1)/yc),(i-1)%yc
return xi*xs,yi*ys
end

3
game/GuiManagerDebug/Misc/IsHovering.int Normal file
View File

@ -0,0 +1,3 @@
function gui:IsHovering()
return (love.mouse.getX() > self.x and love.mouse.getX() < self.x+self.width and love.mouse.getY() > self.y and love.mouse.getY() < self.y+self.height)
end

4
game/GuiManagerDebug/Misc/Move.int Normal file
View File

@ -0,0 +1,4 @@
function gui:Move(x,y)
self.offset.pos.x=self.offset.pos.x+x
self.offset.pos.y=self.offset.pos.y+y
end

46
game/GuiManagerDebug/Misc/SetDualDim.int Normal file
View File

@ -0,0 +1,46 @@
function gui:SetDualDim(x, y, w, h, sx ,sy ,sw ,sh)
if _GuiPro.DPI_ENABLED then
if x then
x=self.DPI*x
end
if y then
y=self.DPI*y
end
if w then
w=self.DPI*w
end
if h then
h=self.DPI*h
end
end
if sx then
self.scale.pos.x=sx
end
if sy then
self.scale.pos.y=sy
end
if x then
self.offset.pos.x=x
end
if y then
self.offset.pos.y=y
end
if sw then
self.scale.size.x=sw
end
if sh then
self.scale.size.y=sh
end
if w then
self.offset.size.x=w
end
if h then
self.offset.size.y=h
end
if self.Image then
self:SetImage(self.Image)
end
end
function gui:setDualDim(...)
self:SetDualDim(...)
end

5
game/GuiManagerDebug/Misc/SetHand.int Normal file
View File

@ -0,0 +1,5 @@
_GuiPro.CursorN=love.mouse.getSystemCursor("arrow")
_GuiPro.CursorH=love.mouse.getSystemCursor("hand")
function gui:SetHand(img,x,y)
_GuiPro.CursorN=love.mouse.newCursor(img,x,y)
end

3
game/GuiManagerDebug/Misc/SetHover.int Normal file
View File

@ -0,0 +1,3 @@
function gui:SetHover(img,x,y)
_GuiPro.CursorH=love.mouse.newCursor(img,x,y)
end

4
game/GuiManagerDebug/Misc/SetName.int Normal file
View File

@ -0,0 +1,4 @@
function gui:SetName(name)
self.Parent.Children[name]=self
self.Name=name
end

10
game/GuiManagerDebug/Misc/TopStack.int Normal file
View File

@ -0,0 +1,10 @@
function gui:TopStack()
childs=self.Parent:getChildren()
for i=1,#childs do
if childs[i]==self then
table.remove(self.Parent.Children,i)
table.insert(self.Parent.Children,self)
break
end
end
end

3
game/GuiManagerDebug/Misc/addDominance.int Normal file
View File

@ -0,0 +1,3 @@
function gui:addDominance()
_GuiPro.TopHovered=self
end

6
game/GuiManagerDebug/Misc/addHotKey.int Normal file
View File

@ -0,0 +1,6 @@
function gui:addHotKey(key)
local temp=self:newFrame(0,0,0,0)
temp.Visible=false
temp:setHotKey(key)
return temp
end

7
game/GuiManagerDebug/Misc/alphanumsort.int Normal file
View File

@ -0,0 +1,7 @@
function alphanumsort(o)
local function padnum(d) local dec, n = string.match(d, "(%.?)0*(.+)")
return #dec > 0 and ("%.12f"):format(d) or ("%s%03d%s"):format(dec, #n, n)
end
table.sort(o, function(a,b) return tostring(a):gsub("%.?%d+",padnum)..("%3d"):format(#b)< tostring(b):gsub("%.?%d+",padnum)..("%3d"):format(#a) end)
return o
end

3
game/GuiManagerDebug/Misc/anchorRight.int Normal file
View File

@ -0,0 +1,3 @@
function gui:anchorRight(n)
self:SetDualDim(-(self.width+n),nil,nil,nil,1)
end

3
game/GuiManagerDebug/Misc/centerX.int Normal file
View File

@ -0,0 +1,3 @@
function gui:centerX()
self:SetDualDim(-(self.width/2),nil,nil,nil,.5)
end

3
game/GuiManagerDebug/Misc/centerY.int Normal file
View File

@ -0,0 +1,3 @@
function gui:centerY()
self:SetDualDim(nil,-(self.height/2),nil,nil,nil,.5)
end

3
game/GuiManagerDebug/Misc/disrespectHierarchy.int Normal file
View File

@ -0,0 +1,3 @@
function gui:disrespectHierarchy()
_GuiPro.Hierarchy=false
end

3
game/GuiManagerDebug/Misc/getChildren.int Normal file
View File

@ -0,0 +1,3 @@
function gui:getChildren()
return self.Children
end

3
game/GuiManagerDebug/Misc/getColor.int Normal file
View File

@ -0,0 +1,3 @@
function gui:getColor(cindex)
return Color[cindex]
end

12
game/GuiManagerDebug/Misc/getFullSize.int Normal file
View File

@ -0,0 +1,12 @@
function gui:getFullSize()
local maxx,maxy=-math.huge,-math.huge
local temp = self:GetAllChildren()
for i=1,#temp do
if temp[i].width>maxx then
maxx=temp[i].width+temp[i].offset.pos.x
elseif temp[i].height>maxy then
maxy=temp[i].height+temp[i].offset.pos.y
end
end
return maxx,maxy
end

5
game/GuiManagerDebug/Misc/getHighest.int Normal file
View File

@ -0,0 +1,5 @@
function gui:getHighest()
if self.Children[#self.Children]~=nil then
return self.Children[#self.Children]
end
end

5
game/GuiManagerDebug/Misc/getLowest.int Normal file
View File

@ -0,0 +1,5 @@
function gui:getLowest()
if self.Children[1]~=nil then
return self.Children[1]
end
end

9
game/GuiManagerDebug/Misc/isDescendant.int Normal file
View File

@ -0,0 +1,9 @@
function gui:isDescendant(obj)
local things=obj:GetAllChildren()
for i=1,#things do
if things[i]==self then
return true
end
end
return false
end

3
game/GuiManagerDebug/Misc/isHighest.int Normal file
View File

@ -0,0 +1,3 @@
function gui:isHighest()
return (self==self.Parent:getHighest())
end

3
game/GuiManagerDebug/Misc/isLowest.int Normal file
View File

@ -0,0 +1,3 @@
function gui:isLowest()
return (self==self.Parent:getLowest())
end

6
game/GuiManagerDebug/Misc/massMutate.int Normal file
View File

@ -0,0 +1,6 @@
function gui.massMutate(t,...)
local mut={...}
for i=1,#mut do
mut[i]:Mutate(t)
end
end

41
game/GuiManagerDebug/Misc/newCheckBox.int Normal file
View File

@ -0,0 +1,41 @@
if love.filesystem.exists("CheckBoxes.png") then
_GuiPro.UC=gui:getTile("CheckBoxes.png",0,0,16,16)
_GuiPro.C=gui:getTile("CheckBoxes.png",16,0,16,16)
_GuiPro.UCH=gui:getTile("CheckBoxes.png",0,16,16,16)
_GuiPro.CH=gui:getTile("CheckBoxes.png",16,16,16,16)
end
function gui:newCheckBox(name,x,y)
if not(_GuiPro.UC) then error("CheckBoxes.png not found! Cannot currently use checkbox without the data") end
if type(name)~="String" then
x,y,name=name,x,"CheckBox"
end
local c=self:newImageLabel(_GuiPro.UC,name, x, y, 16,16)
c.Visibility=0
c.check=false
c:OnEnter(function(self)
if self.check then
self:SetImage(_GuiPro.CH)
else
self:SetImage(_GuiPro.UCH)
end
end)
function c:isChecked()
return self.check
end
c:OnExit(function(self)
if self.check then
self:SetImage(_GuiPro.C)
else
self:SetImage(_GuiPro.UC)
end
end)
c:OnReleased(function(b,self)
self.check=not(self.check)
if self.check then
self:SetImage(_GuiPro.CH)
else
self:SetImage(_GuiPro.UCH)
end
end)
return c
end

36
game/GuiManagerDebug/Misc/newMessageBox.int Normal file
View File

@ -0,0 +1,36 @@
function gui:newMessageBox(txt,x,y,w,h,sx,sy,sw,sh)
name="MessageBox"
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("MessageBoxFrame",name, x, y, w, 30, sx ,sy ,sw ,sh)
c.Draggable=true
c.dragbut="r"
c:ApplyGradient{Color.Blue,Color.sexy_purple}
c.BorderSize=0
c:newTextLabel(txt,"Holder",0,0,0,h-30,0,1,1,0).Color=Color.sexy_purple
c.funcO={}
c.funcX={}
c:OnDragStart(function(self)
self:TopStack()
end)
local temp = c:newTextButton("X","Close",-25,5,20,20,1)
temp.Tween=-5
temp.XTween=-2
temp:OnReleased(function(b,self) for i=1,#self.Parent.funcX do self.Parent.funcX[i](self.Parent) end end)
temp.Color=Color.Red
local temp=c:newTextButton("OK","Ok",0,h-65,0,30,.25,1,.5)
temp:OnReleased(function(b,self) for i=1,#self.Parent.funcO do self.Parent.funcO[i](self.Parent) end end)
temp.Color=Color.Green
function c:Close()
self.Visible=false
end
function c:Open()
self.Visible=true
end
function c:OnOk(func)
table.insert(self.funcO,func)
end
function c:OnX(func)
table.insert(self.funcX,func)
end
return c
end

49
game/GuiManagerDebug/Misc/newPart.int Normal file
View File

@ -0,0 +1,49 @@
function gui:newPart(x, y,w ,h , sx ,sy ,sw ,sh)
local c = {}
setmetatable(c, gui)
if self==gui then
c.Parent=_GuiPro
else
c.Parent=self
end
c.funcs={}
c.funcs2={}
c.funcs3={}
c.funcs4={}
c.funcs5={}
c.func6={}
c.func7={}
c.func8={}
c.func9={}
c.func10={}
c.form="rectangle"
c.Color = {255, 255, 255}
c.scale={}
c.scale.size={}
c.scale.size.x=sw or 0
c.scale.size.y=sh or 0
c.offset={}
c.offset.size={}
c.offset.size.x=w or 0
c.offset.size.y=h or 0
c.scale.pos={}
c.scale.pos.x=sx or 0
c.scale.pos.y=sy or 0
c.offset.pos={}
c.offset.pos.x=x or 0
c.offset.pos.y=y or 0
c.VIS=true
c.Visible=true
c.Visibility=1
c.BorderColor={0,0,0}
c.BorderSize=0
c.Type="Part"
c.Name="GuiPart"
_GuiPro.count=_GuiPro.count+1
c.x=(c.Parent.width*c.scale.pos.x)+c.offset.pos.x+c.Parent.x
c.y=(c.Parent.height*c.scale.pos.y)+c.offset.pos.y+c.Parent.y
c.width=(c.Parent.width*c.scale.size.x)+c.offset.size.x
c.height=(c.Parent.height*c.scale.size.y)+c.offset.size.y
table.insert(c.Parent.Children,c)
return c
end

45
game/GuiManagerDebug/Misc/newProgressBar.int Normal file
View File

@ -0,0 +1,45 @@
function gui:newProgressBar(txt,x,y,w,h,sx,sy,sw,sh)
name="newProgressBar"
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("newProgressBarFrame",name, x, y, w, 30, sx ,sy ,sw ,sh)
c.Draggable=true
c.dragbut="r"
c.BorderSize=0
c:ApplyGradient{Color.Blue,Color.sexy_purple}
c:newTextLabel(txt,"Holder",0,0,0,h-30,0,1,1,0).Color=Color.sexy_purple
c.funcO={}
c.funcX={}
c:OnDragStart(function(self)
self:TopStack()
end)
local temp = c:newTextButton("X","Close",-25,5,20,20,1)
temp.Tween=-5
temp.XTween=-2
temp:OnReleased(function(b,self) for i=1,#self.Parent.funcX do self.Parent.funcX[i](self.Parent) end end)
temp.Color=Color.Red
c.BarBG=c:newTextButton("",5,h-65,-10,30,0,1,1)
c.BarBG:ApplyGradient{Color.Red,Color.light_red}
c.Bar=c.BarBG:newTextLabel("",0,0,0,0,0,0,0,1)
c.Bar:ApplyGradient{Color.Green,Color.light_green}
c.BarDisp=c.BarBG:newTextLabel("0%","0%",0,0,0,0,0,0,1,1)
c.BarDisp.Visibility=0
c.BarDisp.Link=c.Bar
c.BarDisp:OnUpdate(function(self)
self.text=self.Link.scale.size.x*100 .."%"
end)
c.Func1={}
function c:On100(func)
table.insert(self.Func1,func)
end
c:OnUpdate(function(self)
if self.Bar.scale.size.x*100>=100 then
for P=1,#self.Func1 do
self.Func1[P](self)
end
end
end)
function c:SetPercentage(n)
self.Bar:SetDualDim(0,0,0,0,0,0,n/100,1)
end
return c
end

42
game/GuiManagerDebug/Misc/newScrollBar.int Normal file
View File

@ -0,0 +1,42 @@
function gui:newScrollBar(color1,color2)
local scrollbar=self:newFrame(-20,0,20,0,1,0,0,1)
scrollbar.funcS={}
scrollbar.Color=color1 or Color.saddle_brown
scrollbar:OnClicked(function(b,self,x,y)
love.mouse.setX(self.x+10)
if y>=10 and y<=self.height-10 then
self.mover:SetDualDim(0,y-10)
end
if y<10 then
love.mouse.setY(10+self.y)
end
if y>self.height-10 then
love.mouse.setY((self.height-10)+self.y)
end
for i=1,#self.funcS do
self.funcS[i](self,self:getPosition())
end
end)
scrollbar:OnEnter(function(self)
self:addDominance()
end)
scrollbar:OnExit(function(self)
self:removeDominance()
end)
scrollbar.mover=scrollbar:newTextButton("","",0,0,20,20)
scrollbar.mover.Color=color2 or Color.light_brown
function scrollbar:getPosition()
return ((self.mover.offset.pos.y)/(self.height-20))*100
end
function scrollbar:setPosition(n)
print((self.height-20),n)
self.mover.offset.pos.y=((self.height-20)/(100/n))
for i=1,#self.funcS do
self.funcS[i](self,self:getPosition())
end
end
function scrollbar:OnScroll(func)
table.insert(self.funcS,func)
end
return scrollbar
end

98
game/GuiManagerDebug/Misc/newScrollMenu.int Normal file
View File

@ -0,0 +1,98 @@
function gui:newScrollMenu(title,tabN,onloop,x, y, w, h, sx ,sy ,sw ,sh)
local Main = self:newFrame(x, y, w, h, sx ,sy ,sw ,sh)
local Title=Main:newTextButton(title,"Title",0,0,0,20,0,0,1)
Title.Tween=-4
Title.FontSize=12
Title:OnReleased(function(b,self)
self.Parent.Tick=not(self.Parent.Tick)
end)
local scroll=Main:newTextButton("","Scroll",-20,20,20,-20,1,0,0,1)
scroll:OnClicked(function(b,self,x,y)
self.Parent.Mover:SetDualDim(0,y-10,20,20)
if self.Parent.Mover.offset.pos.y<0 then
self.Parent.Mover:SetDualDim(0,0,20,20)
end
if self.Parent.Mover.offset.pos.y>self.Parent.height-40 then
self.Parent.Mover:SetDualDim(0,self.Parent.height-40,20,20)
end
local temp = #self.Parent.TList
self.Parent.pos=(math.floor((temp*self.Parent.Mover.offset.pos.y)/self.height))+1
end)
Main:OnUpdate(function(self)
if self.Tick==false then
self.Visibility=0
end
end)
scroll:OnUpdate(function(self)
self.Visible=self.Parent.Tick
end)
local Mover=scroll:newTextLabel("",0,0,20,20)
Main.Mover=Mover
Main.TList=tabN
Main.pos=1
Main.Tick=true
function Main:Update(title,tabN,onloop)
ch=self:getChildren()
for i=#ch,1,-1 do
ch[i]:Destroy()
end
Title=Main:newTextButton(title,"Title",0,0,0,20,0,0,1)
Title.Tween=-4
Title.FontSize=12
Title:OnReleased(function(b,self)
self.Parent.Tick=not(self.Parent.Tick)
end)
scroll=Main:newTextButton("","Scroll",-20,20,20,-20,1,0,0,1)
scroll:OnClicked(function(b,self,x,y)
self.Parent.Mover:SetDualDim(0,y-10,20,20)
if self.Parent.Mover.offset.pos.y<0 then
self.Parent.Mover:SetDualDim(0,0,20,20)
end
if self.Parent.Mover.offset.pos.y>self.Parent.height-40 then
self.Parent.Mover:SetDualDim(0,self.Parent.height-40,20,20)
end
local temp = #self.Parent.TList
self.Parent.pos=(math.floor((temp*self.Parent.Mover.offset.pos.y)/self.height))+1
end)
local Mover=scroll:newTextLabel("",0,0,20,20)
Main.Mover=Mover
Main.TList=tabN
Main.pos=1
Main.Tick=true
scroll:OnUpdate(function(self)
self.Visible=self.Parent.Tick
end)
for i=1,math.floor(Main.height/20)-1 do
local temp=Main:newTextButton("","Item"..i,0,i*20,-20,20,0,0,1)
temp.FontSize=10
temp.Tween=-4
temp.pos=i
temp:OnUpdate(function(self)
self.text=self.Parent.TList[(self.Parent.pos+self.pos)-1]
self.Visible=self.Parent.Tick
end)
if onloop then
onloop(temp,i)
end
end
end
io.write(tostring(Main.height).."\n")
for i=1,math.floor(Main.height/20)-1 do
local temp=Main:newTextButton("Item"..i,0,i*20,-20,20,0,0,1)
temp.FontSize=10
temp.Tween=-4
temp.pos=i
temp:OnUpdate(function(self)
if self.Parent.TList[(self.Parent.pos+self.pos)-1]~=nil then
self.text=self.Parent.TList[(self.Parent.pos+self.pos)-1]
else
self.text=""
end
self.Visible=self.Parent.Tick
end)
if onloop then
onloop(temp,i)
end
end
return Main
end

6
game/GuiManagerDebug/Misc/removeAllChildren.int Normal file
View File

@ -0,0 +1,6 @@
function gui:destroyAllChildren()
local c=self.Children
for i=1,#c do
c[i]:Destroy()
end
end

3
game/GuiManagerDebug/Misc/removeDominance.int Normal file
View File

@ -0,0 +1,3 @@
function gui:removeDominance()
_GuiPro.TopHovered=nil
end

3
game/GuiManagerDebug/Misc/respectHierarchy.int Normal file
View File

@ -0,0 +1,3 @@
function gui:respectHierarchy()
_GuiPro.Hierarchy=true
end

4
game/GuiManagerDebug/Misc/round.int Normal file
View File

@ -0,0 +1,4 @@
function gui.round(num, idp)
local mult = 10^(idp or 0)
return math.floor(num * mult + 0.5) / mult
end

3
game/GuiManagerDebug/Misc/setBG.int Normal file
View File

@ -0,0 +1,3 @@
function gui.setBG(i)
gui.ff:SetImage(i)
end

14
game/GuiManagerDebug/Misc/setColor.int Normal file
View File

@ -0,0 +1,14 @@
function gui:setColor(a,b,c)
if type(a)=="string" then
self.Color=Color[a]
elseif type(a)=="number" then
self.Color=Color.new(a,b,c)
end
end
function gui:setTextColor(a,b,c)
if type(a)=="string" then
self.TextColor=Color[a]
elseif type(a)=="number" then
self.TextColor=Color.new(a,b,c)
end
end

3
game/GuiManagerDebug/Misc/setDefualtFont.int Normal file
View File

@ -0,0 +1,3 @@
function gui:setDefualtFont(font)
_defaultfont = font
end

24
game/GuiManagerDebug/Misc/setHotKey.int Normal file
View File

@ -0,0 +1,24 @@
function gui:setHotKey(key)
local tab=key:split("+")
self.hotkeys=tab
self.cooldown=false
self.Alarm=multi:newAlarm(1)
self.Alarm.parent=self
self.args={}
self.funcHK=multi:newConnection()
self.Alarm:OnRing(function(alarm) alarm.parent.cooldown=false end)
function self:OnHotKey(func)
self.funcHK:connect(func)
end
self:OnUpdate(function(self)
if self.cooldown then return end
for i=1,#self.hotkeys do
if not(love.keyboard.isDown(self.hotkeys[i])) then
return
end
end
self.cooldown=true
self.funcHK:Fire(self)
self.Alarm:Reset()
end)
end

3
game/GuiManagerDebug/Misc/setNewFont.int Normal file
View File

@ -0,0 +1,3 @@
function gui:setNewFont(FontSize)
self.Font=love.graphics.setNewFont(tonumber(FontSize))
end

14
game/GuiManagerDebug/Misc/setParent.int Normal file
View File

@ -0,0 +1,14 @@
function gui:setParent(parent,name)-- Needs fixing!!!
local temp=self.Parent:getChildren()
for i=1,#temp do
if temp[i]==self then
table.remove(self.Parent.Children,i)
break
end
end
table.insert(parent.Children,self)
self.Parent=parent
if name then
self:SetName(name)
end
end

14
game/GuiManagerDebug/Misc/setVisibility.int Normal file
View File

@ -0,0 +1,14 @@
function gui:setVisiblity(val)
self.Visible=val
self.oV=val
doto=self:GetAllChildren()
if val==false then
for i=1,#doto do
doto[i].Visible=val
end
else
for i=1,#doto do
doto[i].Visible=doto[i].oV
end
end
end

6
game/GuiManagerDebug/Misc/setgetText.int Normal file
View File

@ -0,0 +1,6 @@
function gui:setText(txt)
self.text=txt
end
function gui:getText(txt)
return self.text
end

178
game/GuiManagerDebug/Text/newTextBox.int Normal file
View File

@ -0,0 +1,178 @@
function string:insert(p,s)
return ("%s%s%s"):format(self:sub(1,p), s, self:sub(p+1))
end
function string:remove(p,l)
l=l or 1
return ("%s%s"):format(self:sub(1,p-1), self:sub(p+l))
end
function gui:newTextBox(t,name, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("TextBox",name, x, y, w, h, sx ,sy ,sw ,sh)
c.ClearOnFocus=false
c.LoseFocusOnEnter=true
c.Tween=0
c.XTween=0
c.FontHeight=_defaultfont:getHeight()
c.Font=_defaultfont
c.FontSize=15
c.TextFormat="center"
c.text = t
c.ttext= t
c.AutoScaleText=false
c.TextVisibility=1
c.Color = {220, 220, 220}
c.TextColor = {0, 0, 0}
c.Active=false
c.hidden=false
c.cursor={0,1}
c.mark=nil
c.arrowkeys=false
c.funcF={function()
love.keyboard.setTextInput(true)
end}
c.cooldown=false
c.cooldown2=false
c.funcE={function()
love.keyboard.setTextInput(false)
end}
function c:triggerEnter()
for cc=1,#self.funcE do
self.funcE[cc](self,self.ttext)
end
self.text=""
self.ttext=""
end
c.Enter=true
c.Alarm=multi:newAlarm(.1)
c.Alarm.parent=c
c.Alarm:OnRing(function(alarm) alarm.parent.cooldown=false end)
c.Alarm2=multi:newAlarm(.5)
c.Alarm2.parent=c
c.Alarm2:OnRing(function(alarm) alarm.parent.cooldown2=false end)
c.ArrowAlarm=multi:newAlarm(.1)
c.ArrowAlarm.parent=c
c.ArrowAlarm:OnRing(function(alarm) alarm.parent.arrowkeys=false end)
function c:OnFocus(func)
table.insert(self.funcF,func)
end
function c:OnEnter(func)
table.insert(self.funcE,func)
end
c:OnClicked(function(b,self)
for cc=1,#self.funcF do
self.funcF[cc](self)
end
if self.Active==false then
if self.ClearOnFocus==true then
self.text=""
self.ttext=""
end
for tb=1,#gui.TB do
if gui.TB[tb]~=nil then
gui.TB[tb].Active=false
end
end
self.Active=true
end
end)
c:OnClicked(function(b,self,x,y)
local dwidth, wrappedtext = _defaultfont:getWrap(self.text:sub(1,self.cursor[1]), self.width)
local height = _defaultfont:getHeight()
if #wrappedtext>=1 then
width= _defaultfont:getWidth(wrappedtext[#wrappedtext])
self.cursor[2]=#wrappedtext
else
self.cursor[2]=1
width=0
end
yc=math.ceil(((y/self.DPI)-(self.FontHeight/2)+self.Tween-self.y)/height)
xc=math.floor(x)
end)
c:AddDrawRuleE(function(self)
if self.Active then
local dwidth, wrappedtext = _defaultfont:getWrap(self.text:sub(1,self.cursor[1]), self.width)
local height = _defaultfont:getHeight()
if #wrappedtext>=1 then
width= _defaultfont:getWidth(wrappedtext[#wrappedtext])
self.cursor[2]=#wrappedtext
else
self.cursor[2]=1
width=0
end
x1=width+2+self.x+self.XTween
y1=(self.y+(height*(self.cursor[2]-1))+(self.FontHeight/2)+self.Tween)*self.DPI
x2=width+2+self.x+self.XTween
y2=(self.y+(self.FontHeight/2)+self.Tween*self.DPI)+height*self.cursor[2]
love.graphics.line(x1,y1,x2,y2)
end
end)
c:OnUpdate(function(self)
if love.keyboard.isDown("backspace") and self.Active and self.cooldown==false then
if #self.text>0 then
self.text = self.text:remove(self.cursor[1])
self.ttext = self.ttext:remove(self.cursor[1])
self.cursor[1]=self.cursor[1]-1
end
self.cooldown=true
self.Alarm:Reset()
elseif love.keyboard.isDown("backspace")==false then
self.cooldown=false
end
if love.keyboard.isDown("left") and self.arrowkeys==false and self.Active then
self.arrowkeys=true
self.cursor[1]=self.cursor[1]-1
if self.cursor[1]<0 then
self.cursor[1]=0
end
self.ArrowAlarm:Reset()
elseif love.keyboard.isDown("right") and self.arrowkeys==false and self.Active then
self.arrowkeys=true
self.cursor[1]=self.cursor[1]+1
if self.cursor[1]>#self.text then
self.cursor[1]=#self.text
end
self.ArrowAlarm:Reset()
end
if love.keyboard.isDown("delete") and self.Active then
if #self.text>0 then
self.text = ""
self.ttext = ""
self.cursor[1]=1
end
elseif (love.keyboard.isDown("lshift") or love.keyboard.isDown("rshift")) and love.keyboard.isDown("return") and self.cooldown2==false then
self.text=self.text.."\n"
self.ttext=self.ttext.."\n"
self.cooldown2=true
c.Alarm2:Reset()
elseif (love.keyboard.isDown("return") or love.keyboard.isDown("enter") or love.keyboard.isDown("kpenter")) and self.Active and self.Enter and not(love.keyboard.isDown("lshift") or love.keyboard.isDown("rshift")) then
if self.LoseFocusOnEnter then
self.Active=false
else
self.Active=true
end
for cc=1,#self.funcE do
self.funcE[cc](self,self.ttext)
end
end
end)
table.insert(gui.TB,c)
return c
end
--TEXT BOX HELPER FUNCTION
function love.textinput(t)
for tb=1,#gui.TB do
if gui.TB[tb]~=nil then
if gui.TB[tb].Active then
if gui.TB[tb].hidden then
--gui.TB[tb].text=gui.TB[tb].text.."*"
gui.TB[tb].text=gui.TB[tb].text:insert(gui.TB[tb].cursor[1],"*")
else
--gui.TB[tb].text=gui.TB[tb].text..t
gui.TB[tb].text=gui.TB[tb].text:insert(gui.TB[tb].cursor[1],t)
end
gui.TB[tb].ttext=gui.TB[tb].ttext:insert(gui.TB[tb].cursor[1],t)
gui.TB[tb].cursor[1]=gui.TB[tb].cursor[1]+1
end
end
end
end

22
game/GuiManagerDebug/Text/newTextButton.int Normal file
View File

@ -0,0 +1,22 @@
function gui:newTextButton(t,name, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("TextButton",name, x, y, w, h, sx ,sy ,sw ,sh)
c.Tween=0
c.XTween=0
c.FontHeight=_defaultfont:getHeight()
c.Font=_defaultfont
c.FontSize=15
c.TextFormat="center"
c.text = t
c.AutoScaleText=false
c.TextVisibility=1 -- 0=invisible,1=solid (self.TextVisibility*254+1)
c.Color = {220, 220, 220}
c.TextColor = {0, 0, 0}
c:OnEnter(function()
love.mouse.setCursor(_GuiPro.CursorH)
end)
c:OnExit(function()
love.mouse.setCursor(_GuiPro.CursorN)
end)
return c
end

16
game/GuiManagerDebug/Text/newTextLabel.int Normal file
View File

@ -0,0 +1,16 @@
function gui:newTextLabel(t,name, x, y, w, h, sx ,sy ,sw ,sh)
x,y,w,h,sx,sy,sw,sh=filter(name, x, y, w, h, sx ,sy ,sw ,sh)
local c=self:newBase("TextLabel",name, x, y, w, h, sx ,sy ,sw ,sh)
c.Tween=0
c.XTween=0
c.FontHeight=_defaultfont:getHeight()
c.Font=_defaultfont
c.FontSize=15
c.TextFormat="center"
c.text = t
c.AutoScaleText=false
c.TextVisibility=1 -- 0=invisible,1=solid (self.TextVisibility*254+1)
c.Color = {220, 220, 220}
c.TextColor = {0, 0, 0}
return c
end

58
game/GuiManagerDebug/init.lua Normal file
View File

@ -0,0 +1,58 @@
utf8 = require("utf8")
_defaultfont = love.graphics.getFont()
gui = {}
gui.__index = gui
gui.TB={}
gui.Version="VERSION" -- Is it really ready for release?
_GuiPro={GBoost=true,hasDrag=false,DragItem={},Children={},Visible=true,count=0,x=0,y=0,height=0,width=0,update=function(self) local things=GetAllChildren2(self) UpdateThings(things) end,draw=function(self) local things=GetAllChildren(self) DrawThings(things) end,getChildren=function(self) return self.Children end}
_GuiPro.Clips={}
_GuiPro.rotate=0
setmetatable(_GuiPro, gui)
function gui:LoadInterface(file)
local add=".int"
if string.find(file,".",1,true) then add="" end
if love.filesystem.exists(file..add) then
a,b=pcall(love.filesystem.load(file..add))
if a then
print("Loaded: "..file)
else
print("Error loading file: "..file)
print(a,b)
end
else
print("File does not exist!")
return false
end
end
function gui.LoadAll(dir)
files=love.filesystem.getDirectoryItems(dir)
for i=1,#files do
if string.sub(files[i],-4)==".int" then
gui:LoadInterface(dir.."/"..files[i])
end
end
end
-- Start Of Load
--gui.LoadAll("GuiManager/LibCore")
gui.LoadAll("GuiManager/Core")
gui.LoadAll("GuiManager/Image-Animation")
gui.LoadAll("GuiManager/Frame")
gui.LoadAll("GuiManager/Item")
gui.LoadAll("GuiManager/Misc")
gui.LoadAll("GuiManager/Text")
gui.LoadAll("GuiManager/Drawing")
gui.LoadAll("GuiManager/Combos")
--gui.LoadAll("GuiManager/WIP")
multi.boost=2
-- End of Load
gui:respectHierarchy()
_GuiPro.width,_GuiPro.height=love.graphics.getDimensions()
multi:newLoop():OnLoop(function() _GuiPro.width,_GuiPro.height=love.graphics.getDimensions() _GuiPro:update() end)
multi:onDraw(function() _GuiPro:draw() end)
gui.ff=gui:newFrame("",0,0,0,0,0,0,1,1)
gui.ff.Color={255,255,255}
gui.ff:OnUpdate(function(self)
self:BottomStack()
end)

73
game/bin/compressors/lzw.lua Normal file
View File

@ -0,0 +1,73 @@
--[[
LZW String Compression demo for Gideros
This code is MIT licensed, see http://www.opensource.org/licenses/mit-license.php
(C) 2013 - Guava7
]]
CLZWCompression = {}
function CLZWCompression:InitDictionary(isEncode)
self.mDictionary = {}
-- local s = " !#$%&'\"()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
local s={}
for i=1,255 do
s[#s+1]=string.char(i)
end
s=table.concat(s)
local len = #s
for i = 1, len do
if isEncode then
self.mDictionary[s:sub(i, i)] = i
else
self.mDictionary[i] = s:sub(i, i)
end
end
self.mDictionaryLen = len
end
function CLZWCompression:Encode(sInput)
self:InitDictionary(true)
local s = ""
local ch
local len = #sInput
local result = {}
local dic = self.mDictionary
local temp
for i = 1, len do
ch = sInput:sub(i, i)
temp = s..ch
if dic[temp] then
s = temp
else
result[#result + 1] = dic[s]
self.mDictionaryLen = self.mDictionaryLen + 1
dic[temp] = self.mDictionaryLen
s = ch
end
end
result[#result + 1] = dic[s]
return result
end
function CLZWCompression:Decode(data)
self:InitDictionary(false)
local dic = self.mDictionary
local entry
local ch
local prevCode, currCode
local result = {}
prevCode = data[1]
result[#result + 1] = dic[prevCode]
for i = 2, #data do
currCode = data[i]
entry = dic[currCode]
if entry then
ch = entry:sub(1, 1)
result[#result + 1] = entry
else
ch = dic[prevCode]:sub(1, 1)
result[#result + 1] = dic[prevCode]..ch
end
dic[#dic + 1] = dic[prevCode]..ch
prevCode = currCode
end
return table.concat(result)
end
return CLZWCompression

30
game/bin/converters/base64.lua Normal file
View File

@ -0,0 +1,30 @@
local base64={}
local bs = { [0] =
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/',
}
local bsd=table.flip(bs)
local char=string.char
function base64.encode(s)
local byte, rep, pad = string.byte, string.rep, 2 - ((#s-1) % 3)
s = (s..rep('\0', pad)):gsub("...", function(cs)
local a, b, c = byte(cs, 1, 3)
return bs[bit.rshift(a,2)] .. bs[bit.bor(bit.lshift(bit.band(a,3),4),bit.rshift(b,4))] .. bs[bit.bor(bit.lshift(bit.band(b,15),2),bit.rshift(c,6))] .. bs[bit.band(c,63)]
end)
return s:sub(1, #s-pad) .. rep('=', pad)
end
function base64.decode(s)
local s=s:match("["..s.."=]+")
local p,cc=s:gsub("=","A")
local r=""
local n=0
s=s:sub(1,#s-#p)..p
for c = 1,#s,4 do
n = bit.lshift(bsd[s:sub(c, c)], 18) + bit.lshift(bsd[s:sub(c+1, c+1)], 12) + bit.lshift(bsd[s:sub(c + 2, c + 2)], 6) + bsd[s:sub(c + 3, c + 3)]
r = r .. char(bit.band(bit.arshift(n, 16), 0xFF)) .. char(bit.band(bit.arshift(n, 8), 0xFF)) .. char(bit.band(n, 0xFF))
end
return r:sub(1,-(cc+1))
end
return base64

72
game/bin/converters/base91.lua Normal file
View File

@ -0,0 +1,72 @@
local base91={}
local b91enc={[0]=
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
'%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
'>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'
}
local b91dec=table.flip(b91enc)
function base91.decode(d)
local l,v,o,b,n = #d,-1,"",0,0
for i in d:gmatch(".") do
local c=b91dec[i]
if not(c) then
-- Continue
else
if v < 0 then
v = c
else
v = v+c*91
b = bit.bor(b, bit.lshift(v,n))
if bit.band(v,8191) then
n = n + 13
else
n = n + 14
end
while true do
o=o..string.char(bit.band(b,255))
b=bit.rshift(b,8)
n=n-8
if not (n>7) then
break
end
end
v=-1
end
end
end
if v + 1>0 then
o=o..string.char(bit.band(bit.bor(b,bit.lshift(v,n)),255))
end
return o
end
function base91.encode(d)
local b,n,o,l=0,0,"",#d
for i in d:gmatch(".") do
b=bit.bor(b,bit.lshift(string.byte(i),n))
n=n+8
if n>13 then
v=bit.band(b,8191)
if v>88 then
b=bit.rshift(b,13)
n=n-13
else
v=bit.band(b,16383)
b=bit.rshift(b,14)
n=n-14
end
o=o..b91enc[v % 91] .. b91enc[math.floor(v / 91)]
end
end
if n>0 then
o=o..b91enc[b % 91]
if n>7 or b>90 then
o=o .. b91enc[math.floor(b / 91)]
end
end
return o
end
return base91

377
game/bin/hashes/md5.lua Normal file
View File

@ -0,0 +1,377 @@
local md5 = {
_VERSION = "md5.lua 1.1.0",
_DESCRIPTION = "MD5 computation in Lua (5.1-3, LuaJIT)",
_URL = "https://github.com/kikito/md5.lua",
_LICENSE = [[
MIT LICENSE
Copyright (c) 2013 Enrique García Cota + Adam Baldwin + hanzao + Equi 4 Software
]]
}
-- bit lib implementions
local char, byte, format, rep, sub =
string.char, string.byte, string.format, string.rep, string.sub
local bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift
local ok, bit = pcall(require, 'bit')
if ok then
bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift = bit.bor, bit.band, bit.bnot, bit.bxor, bit.rshift, bit.lshift
else
ok, bit = pcall(require, 'bit32')
if ok then
bit_not = bit.bnot
local tobit = function(n)
return n <= 0x7fffffff and n or -(bit_not(n) + 1)
end
local normalize = function(f)
return function(a,b) return tobit(f(tobit(a), tobit(b))) end
end
bit_or, bit_and, bit_xor = normalize(bit.bor), normalize(bit.band), normalize(bit.bxor)
bit_rshift, bit_lshift = normalize(bit.rshift), normalize(bit.lshift)
else
local function tbl2number(tbl)
local result = 0
local power = 1
for i = 1, #tbl do
result = result + tbl[i] * power
power = power * 2
end
return result
end
local function expand(t1, t2)
local big, small = t1, t2
if(#big < #small) then
big, small = small, big
end
-- expand small
for i = #small + 1, #big do
small[i] = 0
end
end
local to_bits -- needs to be declared before bit_not
bit_not = function(n)
local tbl = to_bits(n)
local size = math.max(#tbl, 32)
for i = 1, size do
if(tbl[i] == 1) then
tbl[i] = 0
else
tbl[i] = 1
end
end
return tbl2number(tbl)
end
-- defined as local above
to_bits = function (n)
if(n < 0) then
-- negative
return to_bits(bit_not(math.abs(n)) + 1)
end
-- to bits table
local tbl = {}
local cnt = 1
local last
while n > 0 do
last = n % 2
tbl[cnt] = last
n = (n-last)/2
cnt = cnt + 1
end
return tbl
end
bit_or = function(m, n)
local tbl_m = to_bits(m)
local tbl_n = to_bits(n)
expand(tbl_m, tbl_n)
local tbl = {}
for i = 1, #tbl_m do
if(tbl_m[i]== 0 and tbl_n[i] == 0) then
tbl[i] = 0
else
tbl[i] = 1
end
end
return tbl2number(tbl)
end
bit_and = function(m, n)
local tbl_m = to_bits(m)
local tbl_n = to_bits(n)
expand(tbl_m, tbl_n)
local tbl = {}
for i = 1, #tbl_m do
if(tbl_m[i]== 0 or tbl_n[i] == 0) then
tbl[i] = 0
else
tbl[i] = 1
end
end
return tbl2number(tbl)
end
bit_xor = function(m, n)
local tbl_m = to_bits(m)
local tbl_n = to_bits(n)
expand(tbl_m, tbl_n)
local tbl = {}
for i = 1, #tbl_m do
if(tbl_m[i] ~= tbl_n[i]) then
tbl[i] = 1
else
tbl[i] = 0
end
end
return tbl2number(tbl)
end
bit_rshift = function(n, bits)
local high_bit = 0
if(n < 0) then
-- negative
n = bit_not(math.abs(n)) + 1
high_bit = 0x80000000
end
local floor = math.floor
for i=1, bits do
n = n/2
n = bit_or(floor(n), high_bit)
end
return floor(n)
end
bit_lshift = function(n, bits)
if(n < 0) then
-- negative
n = bit_not(math.abs(n)) + 1
end
for i=1, bits do
n = n*2
end
return bit_and(n, 0xFFFFFFFF)
end
end
end
-- convert little-endian 32-bit int to a 4-char string
local function lei2str(i)
local f=function (s) return char( bit_and( bit_rshift(i, s), 255)) end
return f(0)..f(8)..f(16)..f(24)
end
-- convert raw string to big-endian int
local function str2bei(s)
local v=0
for i=1, #s do
v = v * 256 + byte(s, i)
end
return v
end
-- convert raw string to little-endian int
local function str2lei(s)
local v=0
for i = #s,1,-1 do
v = v*256 + byte(s, i)
end
return v
end
-- cut up a string in little-endian ints of given size
local function cut_le_str(s,...)
local o, r = 1, {}
local args = {...}
for i=1, #args do
table.insert(r, str2lei(sub(s, o, o + args[i] - 1)))
o = o + args[i]
end
return r
end
local swap = function (w) return str2bei(lei2str(w)) end
-- An MD5 mplementation in Lua, requires bitlib (hacked to use LuaBit from above, ugh)
-- 10/02/2001 jcw@equi4.com
local CONSTS = {
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476
}
local f=function (x,y,z) return bit_or(bit_and(x,y),bit_and(-x-1,z)) end
local g=function (x,y,z) return bit_or(bit_and(x,z),bit_and(y,-z-1)) end
local h=function (x,y,z) return bit_xor(x,bit_xor(y,z)) end
local i=function (x,y,z) return bit_xor(y,bit_or(x,-z-1)) end
local z=function (ff,a,b,c,d,x,s,ac)
a=bit_and(a+ff(b,c,d)+x+ac,0xFFFFFFFF)
-- be *very* careful that left shift does not cause rounding!
return bit_or(bit_lshift(bit_and(a,bit_rshift(0xFFFFFFFF,s)),s),bit_rshift(a,32-s))+b
end
local function transform(A,B,C,D,X)
local a,b,c,d=A,B,C,D
local t=CONSTS
a=z(f,a,b,c,d,X[ 0], 7,t[ 1])
d=z(f,d,a,b,c,X[ 1],12,t[ 2])
c=z(f,c,d,a,b,X[ 2],17,t[ 3])
b=z(f,b,c,d,a,X[ 3],22,t[ 4])
a=z(f,a,b,c,d,X[ 4], 7,t[ 5])
d=z(f,d,a,b,c,X[ 5],12,t[ 6])
c=z(f,c,d,a,b,X[ 6],17,t[ 7])
b=z(f,b,c,d,a,X[ 7],22,t[ 8])
a=z(f,a,b,c,d,X[ 8], 7,t[ 9])
d=z(f,d,a,b,c,X[ 9],12,t[10])
c=z(f,c,d,a,b,X[10],17,t[11])
b=z(f,b,c,d,a,X[11],22,t[12])
a=z(f,a,b,c,d,X[12], 7,t[13])
d=z(f,d,a,b,c,X[13],12,t[14])
c=z(f,c,d,a,b,X[14],17,t[15])
b=z(f,b,c,d,a,X[15],22,t[16])
a=z(g,a,b,c,d,X[ 1], 5,t[17])
d=z(g,d,a,b,c,X[ 6], 9,t[18])
c=z(g,c,d,a,b,X[11],14,t[19])
b=z(g,b,c,d,a,X[ 0],20,t[20])
a=z(g,a,b,c,d,X[ 5], 5,t[21])
d=z(g,d,a,b,c,X[10], 9,t[22])
c=z(g,c,d,a,b,X[15],14,t[23])
b=z(g,b,c,d,a,X[ 4],20,t[24])
a=z(g,a,b,c,d,X[ 9], 5,t[25])
d=z(g,d,a,b,c,X[14], 9,t[26])
c=z(g,c,d,a,b,X[ 3],14,t[27])
b=z(g,b,c,d,a,X[ 8],20,t[28])
a=z(g,a,b,c,d,X[13], 5,t[29])
d=z(g,d,a,b,c,X[ 2], 9,t[30])
c=z(g,c,d,a,b,X[ 7],14,t[31])
b=z(g,b,c,d,a,X[12],20,t[32])
a=z(h,a,b,c,d,X[ 5], 4,t[33])
d=z(h,d,a,b,c,X[ 8],11,t[34])
c=z(h,c,d,a,b,X[11],16,t[35])
b=z(h,b,c,d,a,X[14],23,t[36])
a=z(h,a,b,c,d,X[ 1], 4,t[37])
d=z(h,d,a,b,c,X[ 4],11,t[38])
c=z(h,c,d,a,b,X[ 7],16,t[39])
b=z(h,b,c,d,a,X[10],23,t[40])
a=z(h,a,b,c,d,X[13], 4,t[41])
d=z(h,d,a,b,c,X[ 0],11,t[42])
c=z(h,c,d,a,b,X[ 3],16,t[43])
b=z(h,b,c,d,a,X[ 6],23,t[44])
a=z(h,a,b,c,d,X[ 9], 4,t[45])
d=z(h,d,a,b,c,X[12],11,t[46])
c=z(h,c,d,a,b,X[15],16,t[47])
b=z(h,b,c,d,a,X[ 2],23,t[48])
a=z(i,a,b,c,d,X[ 0], 6,t[49])
d=z(i,d,a,b,c,X[ 7],10,t[50])
c=z(i,c,d,a,b,X[14],15,t[51])
b=z(i,b,c,d,a,X[ 5],21,t[52])
a=z(i,a,b,c,d,X[12], 6,t[53])
d=z(i,d,a,b,c,X[ 3],10,t[54])
c=z(i,c,d,a,b,X[10],15,t[55])
b=z(i,b,c,d,a,X[ 1],21,t[56])
a=z(i,a,b,c,d,X[ 8], 6,t[57])
d=z(i,d,a,b,c,X[15],10,t[58])
c=z(i,c,d,a,b,X[ 6],15,t[59])
b=z(i,b,c,d,a,X[13],21,t[60])
a=z(i,a,b,c,d,X[ 4], 6,t[61])
d=z(i,d,a,b,c,X[11],10,t[62])
c=z(i,c,d,a,b,X[ 2],15,t[63])
b=z(i,b,c,d,a,X[ 9],21,t[64])
return bit_and(A+a,0xFFFFFFFF),bit_and(B+b,0xFFFFFFFF),
bit_and(C+c,0xFFFFFFFF),bit_and(D+d,0xFFFFFFFF)
end
----------------------------------------------------------------
local function md5_update(self, s)
self.pos = self.pos + #s
s = self.buf .. s
for ii = 1, #s - 63, 64 do
local X = cut_le_str(sub(s,ii,ii+63),4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
assert(#X == 16)
X[0] = table.remove(X,1) -- zero based!
self.a,self.b,self.c,self.d = transform(self.a,self.b,self.c,self.d,X)
end
self.buf = sub(s, math.floor(#s/64)*64 + 1, #s)
return self
end
local function md5_finish(self)
local msgLen = self.pos
local padLen = 56 - msgLen % 64
if msgLen % 64 > 56 then padLen = padLen + 64 end
if padLen == 0 then padLen = 64 end
local s = char(128) .. rep(char(0),padLen-1) .. lei2str(bit_and(8*msgLen, 0xFFFFFFFF)) .. lei2str(math.floor(msgLen/0x20000000))
md5_update(self, s)
assert(self.pos % 64 == 0)
return lei2str(self.a) .. lei2str(self.b) .. lei2str(self.c) .. lei2str(self.d)
end
----------------------------------------------------------------
function md5.new()
return { a = CONSTS[65], b = CONSTS[66], c = CONSTS[67], d = CONSTS[68],
pos = 0,
buf = '',
update = md5_update,
finish = md5_finish }
end
function md5.tohex(s)
return format("%08x%08x%08x%08x", str2bei(sub(s, 1, 4)), str2bei(sub(s, 5, 8)), str2bei(sub(s, 9, 12)), str2bei(sub(s, 13, 16)))
end
function md5.sum(s)
return md5.new():update(s):finish()
end
function md5.sumhexa(s)
return md5.tohex(md5.sum(s))
end
return md5

739
game/bin/init.lua Normal file
View File

@ -0,0 +1,739 @@
bin={}
bin.Version={5,1,0}
bin.stage='stable'
bin.data=''
bin.t='bin'
bin.__index = bin
bin.__tostring=function(self) return self:getData() end
bin.__len=function(self) return self:getlength() end
bin.lastBlockSize=0
bin.streams={}
-- Helpers
function bin.getVersion()
return bin.Version[1]..'.'..bin.Version[2]..'.'..bin.Version[3]
end
require("bin.support.utils")
if jit then
bit=require("bit")
elseif bit32 then
bit=bit32
else
bit=require("bin.numbers.no_jit_bit")
end
base64=require("bin.converters.base64")
base91=require("bin.converters.base91")
bin.lzw=require("bin.compressors.lzw") -- A WIP
bits=require("bin.numbers.bits")
infinabits=require("bin.numbers.infinabits") -- like the bits library but works past 32 bits for 32bit lua and 64 bits for 64 bit lua.
bin.md5=require("bin.hashes.md5")
randomGen=require("bin.numbers.random")
function bin.setBitsInterface(int)
bin.defualtBit=int or bits
end
bin.setBitsInterface()
function bin.normalizeData(data) -- unified function to allow for all types to string
if type(data)=="string" then return data end
if type(data)=="table" then
if data.Type=="bin" or data.Type=="streamable" or data.Type=="buffer" then
return data:getData()
elseif data.Type=="bits" or data.Type=="infinabits" then
return data:toSbytes()
elseif data.Type=="sink" then
-- LATER
else
return ""
end
elseif type(data)=="userdata" then
if tostring(data):sub(1,4)=="file" then
local cur=data:seek("cur")
data:seek("set",0)
local dat=data:read("*a")
data:seek("set",cur)
return dat
else
error("File handles are the only userdata that can be used!")
end
end
end
function bin.resolveType(tab) -- used in getblock for auto object creation. Internal method
if tab.Type then
if tab.Type=="bin" then
return bin.new(tab.data)
elseif tab.Type=="streamable" then
if bin.fileExist(tab.file) then return nil,"Cannot load the stream file, source file does not exist!" end
return bin.stream(tab.file,tab.lock)
elseif tab.Type=="buffer" then
local buf=bin.newDataBuffer(tab.size)
buf[1]=tab:getData()
return buf
elseif tab.Type=="bits" then
local b=bits.new("")
b.data=tab.data
return b
elseif tab.Type=="infinabits" then
local b=infinabits.new("")
b.data=tab.data
return b
elseif tab.Type=="sink" then
return bin.newSync(tab.data)
else -- maybe a type from another library
return tab
end
else return tab end
end
function bin.fileExist(path)
g=io.open(path or '','r')
if path =='' then
p='empty path'
return nil
end
if g~=nil and true or false then
p=(g~=nil and true or false)
end
if g~=nil then
io.close(g)
else
return false
end
return p
end
function bin.toHex(str)
local str=bin.normalizeData(str)
return (str:gsub('.', function (c)
return string.format('%02X', string.byte(c))
end))
end
function bin.fromHex(str)
return (str:gsub('..', function (cc)
return string.char(tonumber(cc, 16))
end))
end
function bin.toBase64(s)
return base64.encode(s)
end
function bin.fromBase64(s)
return base64.decode(s)
end
function bin.toBase91(s)
return base91.encode(s)
end
function bin.fromBase91(s)
return base91.decode(s)
end
-- Constructors
function bin.new(data)
data=bin.normalizeData(data)
local c = {}
setmetatable(c, bin)
c.data=data
c.Type="bin"
c.t="bin"
c.pos=1
c.stream=false
return c
end
function bin.newFromBase64(data)
return bin.new(bin.fromBase64(data))
end
function bin.newFromBase91(data)
return bin.new(bin.fromBase91(data))
end
function bin.newFromHex(data)
return bin.new(bin.fromHex(data))
end
function bin.load(path)
if type(path) ~= "string" then error("Path must be a string!") end
local f = io.open(path, 'rb')
local content = f:read('*a')
f:close()
return bin.new(content)
end
function bin.stream(file,l)
if not(l==false) then l=true end
local c=bin.new()
c.Type="streamable"
c.t="streamable"
if bin.streams[file]~=nil then
c.file=file
c.lock = l
c.workingfile=bin.streams[file][1].workingfile
bin.streams[file][2]=bin.streams[file][2]+1
c.stream=true
return c
end
if bin.fileExist(file) then
c.file=file
c.lock = l
c.workingfile=io.open(file,'rb+')
else
c.file=file
c.lock = l
c.workingfile=io.open(file,'w')
io.close(c.workingfile)
c.workingfile=io.open(file,'rb+')
end
c.stream=true
bin.streams[file]={c,1}
return c
end
function bin.newTempFile()
local c=bin.new()
c.file=file
c.lock = false
c.workingfile=io.tmpfile()
c.stream=true
return c
end
function bin.freshStream(file)
bin.new():tofile(file)
return bin.stream(file,false)
end
function bin.newStreamFileObject(file)
local c=bin.new()
c.Type="streamable"
c.t="streamable"
c.file="FILE_OBJECT"
c.lock = false
c.workingfile=file
c.stream=true
return c
end
-- Core Methods
function bin:canStreamWrite()
return (self.stream and not(self.lock))
end
function bin:getSeek()
if self.stream then
return self.workingfile:seek("cur")+1
else
return self.pos
end
end
function bin:setSeek(n)
if self.stream then
self.workingfile:seek("set",n-1)
else
self.pos=n
end
end
function bin:seek(n)
if self.stream then
if not n then return self.workingfile:seek("cur") end
local cur=self.workingfile:seek("cur")
self.workingfile:seek("set",cur+n)
else
if not n then return self.pos end
if #self.data-(self.pos-1)<n then
print(n-((#self.data)-(self.pos-1)))
self:write(string.rep("\0",n-((#self.data)-(self.pos-1))))
return
end
self.pos=self.pos+n
end
end
function bin:read(n)
if self.stream then
return self.workingfile:read(n)
else
local data=self.data:sub(self.pos,self.pos+n-1)
self.pos=self.pos+n
if data=="" then return end
return data
end
end
function bin:write(data,size)
local data=bin.normalizeData(data)
local dsize=#data
local size=tonumber(size or dsize)
if dsize>size then
data = data:sub(1,size)
elseif dsize<size then
data=data..string.rep("\0",size-dsize)
end
if self:canStreamWrite() then
self.workingfile:write(data)
elseif self.Type=="bin" then
local tab={}
if self.pos==1 then
tab={data,self.data:sub(self.pos+size)}
else
tab={self.data:sub(1,self.pos-1),data,self.data:sub(self.pos+size)}
end
self.pos=self.pos+size
self.data=table.concat(tab)
else
error("Attempted to write to a locked file!")
end
end
function bin:sub(a,b)
local data=""
if self.stream then
local cur=self.workingfile:seek("cur")
self.workingfile:seek("set",a-1)
data=self.workingfile:read(b-(a-1))
self.workingfile:seek("set",cur)
else
data=self.data:sub(a,b)
end
return data
end
function bin:slide(n)
local s=self:getSize()
local buf=bin.newDataBuffer(s)
buf:fillBuffer(1,self:getData())
for i=1,s do
nn=buf[i]+n
if nn>255 then
nn=nn%256
elseif nn<0 then
nn=256-math.abs(nn)
end
buf[i]=nn
end
self:setSeek(1)
self:write(buf:getData())
end
function bin:getData(a,b,fmt)
local data=""
if a or b then
data=self:sub(a,b)
else
if self.stream then
local cur=self.workingfile:seek("cur")
self.workingfile:seek("set",0)
data=self.workingfile:read("*a")
self.workingfile:seek("set",cur)
else
data=self.data
end
end
if fmt=="%x" or fmt=="hex" then
return bin.toHex(data):lower()
elseif fmt=="%X" or fmt=="HEX" then
return bin.toHex(data)
elseif fmt=="%b" or fmt=="b64" then
return bin.toB64(data)
elseif fmt then
return bin.new(data):getBlock(fmt,#data)
end
return data
end
function bin:getSize(fmt)
local len=0
if self.stream then
local cur=self.workingfile:seek("cur")
len=self.workingfile:seek("end")
self.workingfile:seek("set",cur)
else
len=#self.data
end
if fmt=="%b" then
return bin.toB64()
elseif fmt then
return string.format(fmt, len)
else
return len
end
end
function bin:tackE(data,size,h)
local data=bin.normalizeData(data)
local cur=self:getSize()
self:setSeek(self:getSize()+1)
self:write(data,size)
if h then
self:setSeek(cur+1)
end
end
function bin:tonumber(a,b)
local temp={}
if a then
temp.data=self:sub(a,b)
else
temp=self
end
local l,r=0,0
local g=#temp.data
for i=1,g do
r=r+(256^(g-i))*string.byte(string.sub(temp.data,i,i))
l=l+(256^(i-1))*string.byte(string.sub(temp.data,i,i))
end
return r,l
end
function bin.endianflop(data)
return string.reverse(data)
end
function bin:tofile(name)
if self.stream then return end
if not name then error("Must include a filename to save as!") end
file = io.open(name, "wb")
file:write(self.data)
file:close()
end
function bin:close()
if self.stream then
if bin.streams[self.file][2]==1 then
bin.streams[self.file]=nil
self.workingfile:close()
else
bin.streams[self.file][2]=bin.streams[self.file][2]-1
self.workingfile=io.tmpfile()
self.workingfile:close()
end
end
end
function bin:getBlock(t,n)
local data=""
if not n then
if bin.registerBlocks[t] then
return bin.registerBlocks[t][1](nil,self)
else
error("Unknown format! Cannot read from file: "..tostring(t))
end
else
if t=="n" or t=="%e" or t=="%E" then
data=self:read(n)
local numB=bin.defualtBit.new(data)
local numL=bin.defualtBit.new(string.reverse(data))
local little=numL:tonumber(0)
local big=numB:tonumber(0)
if t=="%E" then
return big
elseif t=="%X" then
return bin.toHex(data):upper()
elseif t=="%x" then
return bin.toHex(data):lower()
elseif t=="%b" then
return bin.toB64(data)
elseif t=="%e" then
return little
end
return big,little
elseif t=="s" then
return self:read(n)
elseif bin.registerBlocks[t] then
return bin.registerBlocks[t][1](n,self)
else
error("Unknown format! Cannot read from file: "..tostring(t))
end
end
end
function bin:addBlock(d,fit,fmt)
if not fmt then fmt=type(d):sub(1,1) end
if bin.registerBlocks[fmt] then
self:tackE(bin.registerBlocks[fmt][2](d,fit,fmt,self,bin.registerBlocks[fmt][2]))
elseif type(d)=="number" then
local data=bin.defualtBit.numToBytes(d,fit or 4,fmt,function()
error("Overflow! Space allotted for number is smaller than the number takes up. Increase the fit!")
end)
self:tackE(data)
elseif type(d)=="string" then
local data=d:sub(1,fit or -1)
if #data<(fit or #data) then
data=data..string.rep("\0",fit-#data)
end
self:tackE(data)
end
end
bin.registerBlocks={}
function bin.registerBlock(t,funcG,funcA)
bin.registerBlocks[t]={funcG,funcA}
end
function bin.newDataBuffer(size,fill) -- fills with \0 or nul or with what you enter
local c={}
local fill=fill or "\0"
c.data={self=c}
c.Type="buffer"
c.size=size or 0 -- 0 means an infinite buffer, sometimes useful
for i=1,c.size do
c.data[i]=fill
end
local mt={
__index=function(t,k)
if type(k)=="number" then
local data=t.data[k]
if data then
return string.byte(data)
else
error("Index out of range!")
end
elseif type(k)=="string" then
local num=tonumber(k)
if num then
local data=t.data[num]
if data then
return data
else
error("Index out of range!")
end
else
error("Only number-strings and numbers can be indexed!")
end
else
error("Only number-strings and numbers can be indexed!")
end
end,
__newindex=function(t,k,v)
if type(k)~="number" then error("Can only set a buffers data with a numeric index!") end
local data=""
if type(v)=="string" then
data=v
elseif type(v)=="number" then
data=string.char(v)
else
-- try to normalize the data of type v
data=bin.normalizeData(v)
end
t:fillBuffer(k,data)
end,
__tostring=function(t)
return t:getData()
end,
}
function c:fillBuffer(a,data)
local len=#data
if len==1 then
self.data[a]=data
else
local i=a-1
for d in data:gmatch(".") do
i=i+1
if i>c.size then
return #data-i+a
end
self.data[i]=d
end
return #data-i+(a-1)
end
end
function c:getData(a,b,fmt) -- LATER
local dat=bin.new(table.concat(self.data,"",a,b))
local n=dat:getSize()
return dat:getBlock(fmt or "s",n)
end
function c:getSize()
return #self:getData()
end
setmetatable(c,mt)
return c
end
function bin:newDataBufferFromStream(pos,size,fill) -- fills with \0 or nul or with what you enter IF the nothing exists inside the bin file.
local s=self:getSize()
if not self.stream then error("Can only created a streamed buffer on a streamable file!") end
if s==0 then
self:write(string.rep("\0",pos+size))
end
self:setSeek(1)
local c=bin.newDataBuffer(size,fill)
rawset(c,"pos",pos)
rawset(c,"size",size)
rawset(c,"fill",fill)
rawset(c,"bin",self)
rawset(c,"sync",function(self)
local cur=self.bin:getSeek()
self.bin:setSeek(self.pos)
self.bin:write(self:getData(),size)
self.bin:setSeek(cur)
end)
c:fillBuffer(1,self:sub(pos,pos+size))
function c:fillBuffer(a,data)
local len=#data
if len==1 then
self.data[a]=data
self:sync()
else
local i=a-1
for d in data:gmatch(".") do
i=i+1
if i>c.size then
self:sync()
return #data-i+a
end
self.data[i]=d
end
self:sync()
return #data-i+(a-1)
end
end
return c
end
function bin:toDataBuffer()
local s=self:getSize()
-- if self:canStreamWrite() then
-- return self:newDataBufferFromStream(0,s)
-- end
local buf=bin.newDataBuffer(s)
local data=self:read(512)
local i=1
while data~=nil do
buf[i]=data
data=self:read(512)
i=i+512
end
return buf
end
function bin:getMD5Hash()
self:setSeek(1)
local len=self:getSize()
local md5=bin.md5.new()
local SIZE=2048
if len>SIZE then
local dat=self:read(SIZE)
while dat~=nil do
md5:update(dat)
dat=self:read(SIZE)
end
return bin.md5.tohex(md5:finish()):upper()
else
return bin.md5.sumhexa(self:getData()):upper()
end
end
function bin:getHash()
if self:getSize()==0 then
return "NaN"
end
n=32
local rand = randomGen:newND(1,self:getSize(),self:getSize())
local h,g={},0
for i=1,n do
g=rand:nextInt()
table.insert(h,bin.toHex(self:sub(g,g)))
end
return table.concat(h,'')
end
function bin:flipbits()
if self:canStreamWrite() then
self:setSeek(1)
for i=1,self:getSize() do
self:write(string.char(255-string.byte(self:sub(i,i))))
end
else
local temp={}
for i=1,#self.data do
table.insert(temp,string.char(255-string.byte(string.sub(self.data,i,i))))
end
self.data=table.concat(temp,'')
end
end
function bin:encrypt()
self:flipbits()
end
function bin:decrypt()
self:flipbits()
end
-- Use with small files!
function bin:gsub(...)
local data=self:getData()
local pos=self:getSeek()
self:setSeek(1)
self:write((data:gsub(...)) or data)
self:setSeek(loc)
end
function bin:gmatch(pat)
return self:getData():gmatch(pat)
end
function bin:match(pat)
return self:getData():match(pat)
end
function bin:trim()
local data=self:getData()
local pos=self:getSeek()
self:setSeek(1)
self:write(data:match'^()%s*$' and '' or data:match'^%s*(.*%S)')
self:setSeek(loc)
end
function bin:lines()
local t = {}
local function helper(line) table.insert(t, line) return '' end
helper((self:getData():gsub('(.-)\r?\n', helper)))
return t
end
function bin._lines(str)
local t = {}
local function helper(line) table.insert(t, line) return '' end
helper((str:gsub('(.-)\r?\n', helper)))
return t
end
function bin:wipe()
if self:canStreamWrite() then
self:close()
local c=bin.freshStream(self.file)
self.workingfile=c.workingfile
else
self.data=""
end
self:setSeek(1)
end
function bin:fullTrim(empty)
local t=self:lines()
for i=#t,1,-1 do
t[i]=bin._trim(t[i])
if empty then
if t[i]=="" then
table.remove(t,i)
end
end
end
self:wipe()
self:write(table.concat(t,"\n"))
end
require("bin.support.extraBlocks") -- registered blocks that you can use
if love then
function bin.load(file,s,r)
content, size = love.filesystem.read(file)
local temp=bin.new(content)
temp.filepath=file
return temp
end
function bin:tofile(filename)
if not(filename) or self.Stream then return nil end
love.filesystem.write(filename,self.data)
end
function bin.stream(file)
return bin.newStreamFileObject(love.filesystem.newFile(file))
end
function bin:getSize(fmt)
local len=0
if self.stream then
local len=self.workingfile:getSize()
else
len=#self.data
end
if fmt=="%b" then
return bin.toB64()
elseif fmt then
return string.format(fmt, len)
else
return len
end
end
function bin:getSeek()
if self.stream then
return self.workingfile:tell()+1
else
return self.pos
end
end
function bin:setSeek(n)
if self.stream then
self.workingfile:seek(n-1)
else
self.pos=n
end
end
function bin:seek(n)
if self.stream then
self.workingfile:seek(n)
else
if not n then return self.pos end
if #self.data-(self.pos-1)<n then
print(n-((#self.data)-(self.pos-1)))
self:write(string.rep("\0",n-((#self.data)-(self.pos-1))))
return
end
self.pos=self.pos+n
end
end
function bin:close()
self.workingfile:close()
end
end

683
game/bin/numbers/BigNum.lua Normal file
View File

@ -0,0 +1,683 @@
RADIX = 10^7 ;
RADIX_LEN = math.floor( math.log10 ( RADIX ) ) ;
BigNum = {} ;
BigNum.mt = {} ;
function BigNum.new( num ) --{{{2
local bignum = {} ;
setmetatable( bignum , BigNum.mt ) ;
BigNum.change( bignum , num ) ;
return bignum ;
end
function BigNum.mt.sub( num1 , num2 )
local temp = BigNum.new() ;
local bnum1 = BigNum.new( num1 ) ;
local bnum2 = BigNum.new( num2 ) ;
BigNum.sub( bnum1 , bnum2 , temp ) ;
return temp ;
end
function BigNum.mt.mod( num1 , num2 )
return BigNum.new(num1 - (num1/num2)*num2)
end
function BigNum.mt.add( num1 , num2 )
local temp = BigNum.new() ;
local bnum1 = BigNum.new( num1 ) ;
local bnum2 = BigNum.new( num2 ) ;
BigNum.add( bnum1 , bnum2 , temp ) ;
return temp ;
end
function BigNum.mt.mul( num1 , num2 )
local temp = BigNum.new() ;
local bnum1 = BigNum.new( num1 ) ;
local bnum2 = BigNum.new( num2 ) ;
BigNum.mul( bnum1 , bnum2 , temp ) ;
return temp ;
end
function BigNum.mt.div( num1 , num2 )
local bnum1 = {} ;
local bnum2 = {} ;
local bnum3 = BigNum.new() ;
local bnum4 = BigNum.new() ;
bnum1 = BigNum.new( num1 ) ;
bnum2 = BigNum.new( num2 ) ;
BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
return bnum3 , bnum4 ;
end
function BigNum.mt.tostring( bnum )
local i = 0 ;
local j = 0 ;
local str = "" ;
local temp = "" ;
if bnum == nil then
return "nil" ;
elseif bnum.len > 0 then
for i = bnum.len - 2 , 0 , -1 do
for j = 0 , RADIX_LEN - string.len( bnum[i] ) - 1 do
temp = temp .. '0' ;
end
temp = temp .. bnum[i] ;
end
if bnum[bnum.len - 1]==nil then
return "nil"
end
temp = bnum[bnum.len - 1] .. temp ;
if bnum.signal == '-' then
temp = bnum.signal .. temp ;
end
return temp ;
else
return "" ;
end
end
function BigNum.mt.pow( num1 , num2 )
local bnum1 = BigNum.new( num1 ) ;
local bnum2 = BigNum.new( num2 ) ;
return BigNum.pow( bnum1 , bnum2 ) ;
end
function BigNum.mt.eq( num1 , num2 )
local bnum1 = BigNum.new( num1 ) ;
local bnum2 = BigNum.new( num2 ) ;
return BigNum.eq( bnum1 , bnum2 ) ;
end
function BigNum.mt.lt( num1 , num2 )
local bnum1 = BigNum.new( num1 ) ;
local bnum2 = BigNum.new( num2 ) ;
return BigNum.lt( bnum1 , bnum2 ) ;
end
function BigNum.mt.le( num1 , num2 )
local bnum1 = BigNum.new( num1 ) ;
local bnum2 = BigNum.new( num2 ) ;
return BigNum.le( bnum1 , bnum2 ) ;
end
function BigNum.mt.unm( num )
local ret = BigNum.new( num )
if ret.signal == '+' then
ret.signal = '-'
else
ret.signal = '+'
end
return ret
end
BigNum.mt.__metatable = "hidden"
BigNum.mt.__tostring = BigNum.mt.tostring ;
BigNum.mt.__add = BigNum.mt.add ;
BigNum.mt.__sub = BigNum.mt.sub ;
BigNum.mt.__mul = BigNum.mt.mul ;
BigNum.mt.__div = BigNum.mt.div ;
BigNum.mt.__pow = BigNum.mt.pow ;
BigNum.mt.__unm = BigNum.mt.unm ;
BigNum.mt.__mod = BigNum.mt.mod ;
BigNum.mt.__eq = BigNum.mt.eq ;
BigNum.mt.__le = BigNum.mt.le ;
BigNum.mt.__lt = BigNum.mt.lt ;
setmetatable( BigNum.mt, { __index = "inexistent field", __newindex = "not available", __metatable="hidden" } ) ;
function BigNum.add( bnum1 , bnum2 , bnum3 )
local maxlen = 0 ;
local i = 0 ;
local carry = 0 ;
local signal = '+' ;
local old_len = 0 ;
--Handle the signals
if bnum1 == nil or bnum2 == nil or bnum3 == nil then
error("Function BigNum.add: parameter nil") ;
elseif bnum1.signal == '-' and bnum2.signal == '+' then
bnum1.signal = '+' ;
BigNum.sub( bnum2 , bnum1 , bnum3 ) ;
if not rawequal(bnum1, bnum3) then
bnum1.signal = '-' ;
end
return 0 ;
elseif bnum1.signal == '+' and bnum2.signal == '-' then
bnum2.signal = '+' ;
BigNum.sub( bnum1 , bnum2 , bnum3 ) ;
if not rawequal(bnum2, bnum3) then
bnum2.signal = '-' ;
end
return 0 ;
elseif bnum1.signal == '-' and bnum2.signal == '-' then
signal = '-' ;
end
--
old_len = bnum3.len ;
if bnum1.len > bnum2.len then
maxlen = bnum1.len ;
else
maxlen = bnum2.len ;
bnum1 , bnum2 = bnum2 , bnum1 ;
end
--School grade sum
for i = 0 , maxlen - 1 do
if bnum2[i] ~= nil then
bnum3[i] = bnum1[i] + bnum2[i] + carry ;
else
bnum3[i] = bnum1[i] + carry ;
end
if bnum3[i] >= RADIX then
bnum3[i] = bnum3[i] - RADIX ;
carry = 1 ;
else
carry = 0 ;
end
end
--Update the answer's size
if carry == 1 then
bnum3[maxlen] = 1 ;
end
bnum3.len = maxlen + carry ;
bnum3.signal = signal ;
for i = bnum3.len, old_len do
bnum3[i] = nil ;
end
return 0 ;
end
function BigNum.sub( bnum1 , bnum2 , bnum3 )
local maxlen = 0 ;
local i = 0 ;
local carry = 0 ;
local old_len = 0 ;
if bnum1 == nil or bnum2 == nil or bnum3 == nil then
error("Function BigNum.sub: parameter nil") ;
elseif bnum1.signal == '-' and bnum2.signal == '+' then
bnum1.signal = '+' ;
BigNum.add( bnum1 , bnum2 , bnum3 ) ;
bnum3.signal = '-' ;
if not rawequal(bnum1, bnum3) then
bnum1.signal = '-' ;
end
return 0 ;
elseif bnum1.signal == '-' and bnum2.signal == '-' then
bnum1.signal = '+' ;
bnum2.signal = '+' ;
BigNum.sub( bnum2, bnum1 , bnum3 ) ;
if not rawequal(bnum1, bnum3) then
bnum1.signal = '-' ;
end
if not rawequal(bnum2, bnum3) then
bnum2.signal = '-' ;
end
return 0 ;
elseif bnum1.signal == '+' and bnum2.signal == '-' then
bnum2.signal = '+' ;
BigNum.add( bnum1 , bnum2 , bnum3 ) ;
if not rawequal(bnum2, bnum3) then
bnum2.signal = '-' ;
end
return 0 ;
end
--Tests if bnum2 > bnum1
if BigNum.compareAbs( bnum1 , bnum2 ) == 2 then
BigNum.sub( bnum2 , bnum1 , bnum3 ) ;
bnum3.signal = '-' ;
return 0 ;
else
maxlen = bnum1.len ;
end
old_len = bnum3.len ;
bnum3.len = 0 ;
--School grade subtraction
for i = 0 , maxlen - 1 do
if bnum2[i] ~= nil then
bnum3[i] = bnum1[i] - bnum2[i] - carry ;
else
bnum3[i] = bnum1[i] - carry ;
end
if bnum3[i] < 0 then
bnum3[i] = RADIX + bnum3[i] ;
carry = 1 ;
else
carry = 0 ;
end
if bnum3[i] ~= 0 then
bnum3.len = i + 1 ;
end
end
bnum3.signal = '+' ;
--Check if answer's size if zero
if bnum3.len == 0 then
bnum3.len = 1 ;
bnum3[0] = 0 ;
end
if carry == 1 then
error( "Error in function sub" ) ;
end
for i = bnum3.len , max( old_len , maxlen - 1 ) do
bnum3[i] = nil ;
end
return 0 ;
end
function BigNum.mul( bnum1 , bnum2 , bnum3 )
local i = 0 ; j = 0 ;
local temp = BigNum.new( ) ;
local temp2 = 0 ;
local carry = 0 ;
local oldLen = bnum3.len ;
if bnum1 == nil or bnum2 == nil or bnum3 == nil then
error("Function BigNum.mul: parameter nil") ;
--Handle the signals
elseif bnum1.signal ~= bnum2.signal then
BigNum.mul( bnum1 , -bnum2 , bnum3 ) ;
bnum3.signal = '-' ;
return 0 ;
end
bnum3.len = ( bnum1.len ) + ( bnum2.len ) ;
--Fill with zeros
for i = 1 , bnum3.len do
bnum3[i - 1] = 0 ;
end
--Places nil where passes through this
for i = bnum3.len , oldLen do
bnum3[i] = nil ;
end
--School grade multiplication
for i = 0 , bnum1.len - 1 do
for j = 0 , bnum2.len - 1 do
carry = ( bnum1[i] * bnum2[j] + carry ) ;
carry = carry + bnum3[i + j] ;
bnum3[i + j] = ( carry % RADIX ) ;
temp2 = bnum3[i + j] ;
carry = math.floor ( carry / RADIX ) ;
end
if carry ~= 0 then
bnum3[i + bnum2.len] = carry ;
end
carry = 0 ;
end
--Update the answer's size
for i = bnum3.len - 1 , 1 , -1 do
if bnum3[i] ~= nil and bnum3[i] ~= 0 then
break ;
else
bnum3[i] = nil ;
end
bnum3.len = bnum3.len - 1 ;
end
return 0 ;
end
function BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 )
local temp = BigNum.new() ;
local temp2 = BigNum.new() ;
local one = BigNum.new( "1" ) ;
local zero = BigNum.new( "0" ) ;
--Check division by zero
if BigNum.compareAbs( bnum2 , zero ) == 0 then
error( "Function BigNum.div: Division by zero" ) ;
end
--Handle the signals
if bnum1 == nil or bnum2 == nil or bnum3 == nil or bnum4 == nil then
error( "Function BigNum.div: parameter nil" ) ;
elseif bnum1.signal == "+" and bnum2.signal == "-" then
bnum2.signal = "+" ;
BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
bnum2.signal = "-" ;
bnum3.signal = "-" ;
return 0 ;
elseif bnum1.signal == "-" and bnum2.signal == "+" then
bnum1.signal = "+" ;
BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
bnum1.signal = "-" ;
if bnum4 < zero then --Check if remainder is negative
BigNum.add( bnum3 , one , bnum3 ) ;
BigNum.sub( bnum2 , bnum4 , bnum4 ) ;
end
bnum3.signal = "-" ;
return 0 ;
elseif bnum1.signal == "-" and bnum2.signal == "-" then
bnum1.signal = "+" ;
bnum2.signal = "+" ;
BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ;
bnum1.signal = "-" ;
if bnum4 < zero then --Check if remainder is negative
BigNum.add( bnum3 , one , bnum3 ) ;
BigNum.sub( bnum2 , bnum4 , bnum4 ) ;
end
bnum2.signal = "-" ;
return 0 ;
end
temp.len = bnum1.len - bnum2.len - 1 ;
--Reset variables
BigNum.change( bnum3 , "0" ) ;
BigNum.change( bnum4 , "0" ) ;
BigNum.copy( bnum1 , bnum4 ) ;
--Check if can continue dividing
while( BigNum.compareAbs( bnum4 , bnum2 ) ~= 2 ) do
if bnum4[bnum4.len - 1] >= bnum2[bnum2.len - 1] then
BigNum.put( temp , math.floor( bnum4[bnum4.len - 1] / bnum2[bnum2.len - 1] ) , bnum4.len - bnum2.len ) ;
temp.len = bnum4.len - bnum2.len + 1 ;
else
BigNum.put( temp , math.floor( ( bnum4[bnum4.len - 1] * RADIX + bnum4[bnum4.len - 2] ) / bnum2[bnum2.len -1] ) , bnum4.len - bnum2.len - 1 ) ;
temp.len = bnum4.len - bnum2.len ;
end
if bnum4.signal ~= bnum2.signal then
temp.signal = "-";
else
temp.signal = "+";
end
BigNum.add( temp , bnum3 , bnum3 ) ;
temp = temp * bnum2 ;
BigNum.sub( bnum4 , temp , bnum4 ) ;
end
--Update if the remainder is negative
if bnum4.signal == '-' then
decr( bnum3 ) ;
BigNum.add( bnum2 , bnum4 , bnum4 ) ;
end
return 0 ;
end
function BigNum.pow( bnum1 , bnum2 )
local n = BigNum.new( bnum2 ) ;
local y = BigNum.new( 1 ) ;
local z = BigNum.new( bnum1 ) ;
local zero = BigNum.new( "0" ) ;
if bnum2 < zero then
error( "Function BigNum.exp: domain error" ) ;
elseif bnum2 == zero then
return y ;
end
while 1 do
if ( n[0] % 2 ) == 0 then
n = n / 2 ;
else
n = n / 2 ;
y = z * y ;
if n == zero then
return y ;
end
end
z = z * z ;
end
end
-- Português :
BigNum.exp = BigNum.pow
function BigNum.gcd( bnum1 , bnum2 )
local a = {} ;
local b = {} ;
local c = {} ;
local d = {} ;
local zero = {} ;
zero = BigNum.new( "0" ) ;
if bnum1 == zero or bnum2 == zero then
return BigNum.new( "1" ) ;
end
a = BigNum.new( bnum1 ) ;
b = BigNum.new( bnum2 ) ;
a.signal = '+' ;
b.signal = '+' ;
c = BigNum.new() ;
d = BigNum.new() ;
while b > zero do
BigNum.div( a , b , c , d ) ;
a , b , d = b , d , a ;
end
return a ;
end
-- Português:
BigNum.mmc = BigNum.gcd
function BigNum.eq( bnum1 , bnum2 )
if BigNum.compare( bnum1 , bnum2 ) == 0 then
return true ;
else
return false ;
end
end
function BigNum.lt( bnum1 , bnum2 )
if BigNum.compare( bnum1 , bnum2 ) == 2 then
return true ;
else
return false ;
end
end
function BigNum.le( bnum1 , bnum2 )
local temp = -1 ;
temp = BigNum.compare( bnum1 , bnum2 )
if temp == 0 or temp == 2 then
return true ;
else
return false ;
end
end
function BigNum.compareAbs( bnum1 , bnum2 )
if bnum1 == nil or bnum2 == nil then
error("Function compare: parameter nil") ;
elseif bnum1.len > bnum2.len then
return 1 ;
elseif bnum1.len < bnum2.len then
return 2 ;
else
local i ;
for i = bnum1.len - 1 , 0 , -1 do
if bnum1[i] > bnum2[i] then
return 1 ;
elseif bnum1[i] < bnum2[i] then
return 2 ;
end
end
end
return 0 ;
end
function BigNum.compare( bnum1 , bnum2 )
local signal = 0 ;
if bnum1 == nil or bnum2 == nil then
error("Funtion BigNum.compare: parameter nil") ;
elseif bnum1.signal == '+' and bnum2.signal == '-' then
return 1 ;
elseif bnum1.signal == '-' and bnum2.signal == '+' then
return 2 ;
elseif bnum1.signal == '-' and bnum2.signal == '-' then
signal = 1 ;
end
if bnum1.len > bnum2.len then
return 1 + signal ;
elseif bnum1.len < bnum2.len then
return 2 - signal ;
else
local i ;
for i = bnum1.len - 1 , 0 , -1 do
if bnum1[i] > bnum2[i] then
return 1 + signal ;
elseif bnum1[i] < bnum2[i] then
return 2 - signal ;
end
end
end
return 0 ;
end
function BigNum.copy( bnum1 , bnum2 )
if bnum1 ~= nil and bnum2 ~= nil then
local i ;
for i = 0 , bnum1.len - 1 do
bnum2[i] = bnum1[i] ;
end
bnum2.len = bnum1.len ;
else
error("Function BigNum.copy: parameter nil") ;
end
end
function BigNum.change( bnum1 , num )
local j = 0 ;
local len = 0 ;
local num = num ;
local l ;
local oldLen = 0 ;
if bnum1 == nil then
error( "BigNum.change: parameter nil" ) ;
elseif type( bnum1 ) ~= "table" then
error( "BigNum.change: parameter error, type unexpected" ) ;
elseif num == nil then
bnum1.len = 1 ;
bnum1[0] = 0 ;
bnum1.signal = "+";
elseif type( num ) == "table" and num.len ~= nil then --check if num is a big number
--copy given table to the new one
for i = 0 , num.len do
bnum1[i] = num[i] ;
end
if num.signal ~= '-' and num.signal ~= '+' then
bnum1.signal = '+' ;
else
bnum1.signal = num.signal ;
end
oldLen = bnum1.len ;
bnum1.len = num.len ;
elseif type( num ) == "string" or type( num ) == "number" then
if string.sub( num , 1 , 1 ) == '+' or string.sub( num , 1 , 1 ) == '-' then
bnum1.signal = string.sub( num , 1 , 1 ) ;
num = string.sub(num, 2) ;
else
bnum1.signal = '+' ;
end
num = string.gsub( num , " " , "" ) ;
local sf = string.find( num , "e" ) ;
--Handles if the number is in exp notation
if sf ~= nil then
num = string.gsub( num , "%." , "" ) ;
local e = string.sub( num , sf + 1 ) ;
e = tonumber(e) ;
if e ~= nil and e > 0 then
e = tonumber(e) ;
else
error( "Function BigNum.change: string is not a valid number" ) ;
end
num = string.sub( num , 1 , sf - 2 ) ;
for i = string.len( num ) , e do
num = num .. "0" ;
end
else
sf = string.find( num , "%." ) ;
if sf ~= nil then
num = string.sub( num , 1 , sf - 1 ) ;
end
end
l = string.len( num ) ;
oldLen = bnum1.len ;
if (l > RADIX_LEN) then
local mod = l-( math.floor( l / RADIX_LEN ) * RADIX_LEN ) ;
for i = 1 , l-mod, RADIX_LEN do
bnum1[j] = tonumber( string.sub( num, -( i + RADIX_LEN - 1 ) , -i ) );
--Check if string dosn't represents a number
if bnum1[j] == nil then
error( "Function BigNum.change: string is not a valid number" ) ;
bnum1.len = 0 ;
return 1 ;
end
j = j + 1 ;
len = len + 1 ;
end
if (mod ~= 0) then
bnum1[j] = tonumber( string.sub( num , 1 , mod ) ) ;
bnum1.len = len + 1 ;
else
bnum1.len = len ;
end
--Eliminate trailing zeros
for i = bnum1.len - 1 , 1 , -1 do
if bnum1[i] == 0 then
bnum1[i] = nil ;
bnum1.len = bnum1.len - 1 ;
else
break ;
end
end
else
-- string.len(num) <= RADIX_LEN
bnum1[j] = tonumber( num ) ;
bnum1.len = 1 ;
end
else
error( "Function BigNum.change: parameter error, type unexpected" ) ;
end
--eliminates the deprecated higher order 'algarisms'
if oldLen ~= nil then
for i = bnum1.len , oldLen do
bnum1[i] = nil ;
end
end
return 0 ;
end
function BigNum.put( bnum , int , pos )
if bnum == nil then
error("Function BigNum.put: parameter nil") ;
end
local i = 0 ;
for i = 0 , pos - 1 do
bnum[i] = 0 ;
end
bnum[pos] = int ;
for i = pos + 1 , bnum.len do
bnum[i] = nil ;
end
bnum.len = pos ;
return 0 ;
end
--printraw{{{2
function printraw( bnum )
local i = 0 ;
if bnum == nil then
error( "Function printraw: parameter nil" ) ;
end
while 1 == 1 do
if bnum[i] == nil then
io.write( ' len '..bnum.len ) ;
if i ~= bnum.len then
io.write( ' ERRO!!!!!!!!' ) ;
end
io.write( "\n" ) ;
return 0 ;
end
io.write( 'r'..bnum[i] ) ;
i = i + 1 ;
end
end
--max{{{2
function max( int1 , int2 )
if int1 > int2 then
return int1 ;
else
return int2 ;
end
end
--decr{{{2
function decr( bnum1 )
local temp = {} ;
temp = BigNum.new( "1" ) ;
BigNum.sub( bnum1 , temp , bnum1 ) ;
return 0 ;
end

227
game/bin/numbers/BigRat.lua Normal file
View File

@ -0,0 +1,227 @@
require( "bin.numbers.BigNum" ) ;
BigRat = {} ;
BigRat.mt = {} ;
function BigRat.new( num1 , num2 ) --{{{2
local bigrat = {} ;
local f ;
setmetatable(bigrat, BigRat.mt) ;
if type( num1 ) == "table" then
if num1.num ~= nil and num1.den ~= nil then
bigrat.num = BigNum.new( num1.num ) ;
bigrat.den = BigNum.new( num1.den ) ;
else
bigrat.num = BigNum.new( num1 ) ;
bigrat.den = BigNum.new( "1" ) ;
end
elseif num1 ~= nil then
if num2 == nil then
bigrat.den = BigNum.new( "1" ) ;
else
bigrat.den = BigNum.new( num2 ) ;
end
bigrat.num = BigNum.new( num1 ) ;
else
bigrat.den = BigNum.new( ) ;
bigrat.num = BigNum.new( ) ;
end
--Update the signals
if bigrat.den.signal == "-" then
if bigrat.num.signal == "-" then
bigrat.num.signal = "+" ;
else
bigrat.num.signal = "-" ;
end
bigrat.den.signal = "+" ;
end
return bigrat ;
end
function BigRat.mt.sub( num1 , num2 )
local temp = BigRat.new() ;
local brat1 = BigRat.new( num1 ) ;
local brat2 = BigRat.new( num2 ) ;
BigRat.sub( brat1 , brat2 , temp ) ;
return temp ;
end
function BigRat.mt.add( num1 , num2 )
local temp = BigRat.new() ;
local brat1 = BigRat.new( num1 ) ;
local brat2 = BigRat.new( num2 ) ;
BigRat.add( brat1 , brat2 , temp ) ;
return temp ;
end
function BigRat.mt.mul( num1 , num2 )
local temp = BigRat.new() ;
local brat1 = BigRat.new( num1 ) ;
local brat2 = BigRat.new( num2 ) ;
BigRat.mul( brat1 , brat2 , temp ) ;
return temp ;
end
function BigRat.mt.div( num1 , num2 )
local brat1 = BigRat.new( num1 ) ;
local brat2 = BigRat.new( num2 ) ;
local brat3 = BigRat.new() ;
local brat4 = BigRat.new() ;
BigRat.div( brat1 , brat2 , brat3 , brat4 ) ;
return brat3 , brat4 ;
end
function BigRat.mt.tostring( brat )
BigRat.simplify( brat ) ;
return BigNum.mt.tostring( brat.num ) .. " / " .. BigNum.mt.tostring( brat.den ) ;
end
function BigRat.mt.pow ( num1 , num2 )
local brat1 = BigRat.new( num1 ) ;
local brat2 = BigRat.new( num2 ) ;
return BigRat.pow( brat1 , brat2 )
end
function BigRat.mt.eq ( num1 , num2 )
return BigRat.eq( num1 , num2 )
end
function BigRat.mt.lt ( num1 , num2 )
return BigRat.lt( num1 , num2 )
end
function BigRat.mt.le ( num1 , num2 )
return BigRat.le( num1 , num2 )
end
function BigRat.mt.unm ( num )
local ret = BigRat.new( num )
if ret.num.signal == '-' then
ret.num.signal = '+'
else
ret.num.signal = '-'
end
return ret
end
BigRat.mt.__metatable = "hidden"
BigRat.mt.__tostring = BigRat.mt.tostring
BigRat.mt.__add = BigRat.mt.add
BigRat.mt.__sub = BigRat.mt.sub
BigRat.mt.__mul = BigRat.mt.mul
BigRat.mt.__div = BigRat.mt.div
BigRat.mt.__pow = BigRat.mt.pow
BigRat.mt.__unm = BigRat.mt.unm
BigRat.mt.__eq = BigRat.mt.eq
BigRat.mt.__le = BigRat.mt.le
BigRat.mt.__lt = BigRat.mt.lt
setmetatable( BigRat.mt, { __index = "inexistent field", __newindex = "not available", __metatable="hidden" } ) ;
function BigRat.add( brat1 , brat2 , brat3 )
brat3.den = brat1.den * brat2.den ;
brat3.num = ( brat1.num * brat2.den ) + ( brat2.num * brat1.den ) ;
return brat3 ;
end
function BigRat.sub( brat1 , brat2 , brat3 )
brat3.den = brat1.den * brat2.den ;
brat3.num = ( brat1.num * brat2.den ) - ( brat2.num * brat1.den ) ;
return brat3 ;
end
function BigRat.mul( brat1 , brat2 , brat3 )
brat3.num = brat1.num * brat2.num ;
brat3.den = brat1.den * brat2.den ;
return 0 ;
end
function BigRat.div( brat1 , brat2 , brat3 )
brat3.num = brat1.num * brat2.den ;
brat3.den = brat1.den * brat2.num ;
return brat3 ;
end
function BigRat.pow( bnum1 , bnum2 )
if bnum1 == nil or bnum2 == nil then
error( "Function BigRat.pow: parameter nil" ) ;
end
local x = BigRat.new( "8" ) ;
local n = BigRat.new( bnum2.den ) ;
local n2 ;
local y = BigRat.new( ) ;
local i ;
local temp = BigRat.new( ) ;
BigRat.simplify( bnum2 ) ;
temp.num = BigNum.exp( bnum1.num , bnum2.num ) ;
temp.den = BigNum.exp( bnum1.den , bnum2.num ) ;
n2 = n - 1 ;
for i = 0 , 4 do
y.num = x.num ^ n2.num ;
y.den = x.den ^ n2.num ;
x = (( temp / y ) + ( n2 * x )) / n ;
end
return x ;
end
function BigRat.simplify( brat )
if brat == nil then
error( "Function BigRat.simplify: parameter nil" ) ;
end
local gcd = BigNum.new( ) ;
local temp = BigRat.new( brat ) ;
local devnull = BigNum.new( ) ;
local zero = BigNum.new( "0" ) ;
--Check if numerator is zero
if BigNum.compareAbs( brat.num , zero ) == 0 then
brat.den = BigNum.new( "1" ) ;
return 0 ;
end
gcd = BigNum.gcd( brat.num , brat.den ) ;
BigNum.div( temp.num , gcd , brat.num , devnull ) ;
BigNum.div( temp.den , gcd , brat.den , devnull ) ;
--Update the signal
if brat.num.signal == '-' and brat.den.signal == '-' then
brat.num.signal = '+' ;
brat.den.signal = '+' ;
end
return 0 ;
end
function BigRat.eq( brat1 , brat2 )
if BigRat.compare( brat1 , brat2 ) == 0 then
return true ;
else
return false ;
end
end
function BigRat.lt( brat1 , brat2 )
if BigRat.compare( brat1 , brat2 ) == 2 then
return true ;
else
return false ;
end
end
function BigRat.le( brat1 , brat2 )
local temp = -1 ;
temp = BigRat.compare( brat1 , brat2 )
if temp == 0 or temp == 2 then
return true ;
else
return false ;
end
end
function BigRat.compare( bnum1 , bnum2 )
local temp ;
temp = bnum1 - bnum2 ;
if temp.num[0] == 0 and temp.num.len == 1 then --Check if is zero
return 0 ;
elseif temp.num.signal == "-" then
return 2 ;
else
return 1 ;
end
end

191
game/bin/numbers/bits.lua Normal file
View File

@ -0,0 +1,191 @@
local bits={}
bits.data=''
bits.t='bits'
bits.Type='bits'
bits.__index = bits
bits.__tostring=function(self) return self.data end
bits.__len=function(self) return (#self.data)/8 end
local floor,insert = math.floor, table.insert
function bits.newBitBuffer(n)
--
end
function bits.newConverter(bitsIn,bitsOut)
local c={}
--
end
function basen(n,b)
if not b or b == 10 then return tostring(n) end
local digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
local t = {}
local sign = ""
if n < 0 then
sign = "-"
n = -n
end
repeat
local d = n % b + 1
n = n / b
insert(t, 1, digits:sub(d,d))
until n == 0
return sign .. table.concat(t,"")
end
bits.ref={}
function bits.newByte(d)
local c={}
if type(d)=="string" then
if #d>1 or #d<1 then
error("A byte must be one character!")
else
c.data=string.byte(d)
end
elseif type(d)=="number" then
if d>255 or d<0 then
error("A byte must be between 0 and 255!")
else
c.data=d
end
else
error("cannot use type "..type(d).." as an argument! Takes only strings or numbers!")
end
c.__index=function(self,k)
if k>=0 and k<9 then
if self.data==0 then
return 0
elseif self.data==255 then
return 1
else
return bits.ref[self.data][k]
end
end
end
c.__tostring=function(self)
return bits.ref[tostring(self.data)]
end
setmetatable(c,c)
return c
end
function bits.newByteArray(s)
local c={}
if type(s)~="string" then
error("Must be a string type or bin/buffer type")
elseif type(s)=="table" then
if s.t=="sink" or s.t=="buffer" or s.t=="bin" then
local data=s:getData()
for i=1,#data do
c[#c+1]=bits.newByte(data:sub(i,i))
end
else
error("Must be a string type or bin/buffer type")
end
else
for i=1,#s do
c[#c+1]=bits.newByte(s:sub(i,i))
end
end
return c
end
function bits.new(n,binary)
local temp={}
temp.t="bits"
temp.Type="bits"
if type(n)=="string" then
if binary then
temp.data=n:match("[10]+")
else
local t={}
for i=#n,1,-1 do
table.insert(t,bits:conv(string.byte(n,i)))
end
temp.data=table.concat(t)
end
elseif type(n)=="number" or type(n)=="table" then
temp.data=basen(n,2)
end
if #temp.data%8~=0 then
temp.data=string.rep('0',8-#temp.data%8)..temp.data
end
setmetatable(temp, bits)
return temp
end
for i=0,255 do
local d=bits.new(i).data
bits.ref[i]={d:match("(%d)(%d)(%d)(%d)(%d)(%d)(%d)(%d)")}
bits.ref[tostring(i)]=d
bits.ref[d]=i
bits.ref["\255"..string.char(i)]=d
end
function bits.numToBytes(n,fit,func)
local num=string.reverse(bits.new(n):toSbytes())
local ref={["num"]=num,["fit"]=fit}
if fit then
if fit<#num then
if func then
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
func(ref)
else
print("Warning: attempting to store a number that takes up more space than allotted!")
end
return ref.num:sub(1,ref.fit)
elseif fit==#num then
return string.reverse(num)
else
return string.reverse(string.rep("\0",fit-#num)..num)
end
else
return string.reverse(num)
end
end
function bits:conv(n)
local tab={}
while n>=1 do
table.insert(tab,n%2)
n=math.floor(n/2)
end
local str=string.reverse(table.concat(tab))
if #str%8~=0 or #str==0 then
str=string.rep('0',8-#str%8)..str
end
return str
end
function bits:tonumber(s,e)
if s==0 then
return tonumber(self.data,2)
end
s=s or 1
return tonumber(string.sub(self.data,(8*(s-1))+1,8*s),2) or error('Bounds!')
end
function bits:isover()
return #self.data>8
end
function bits:flipbits()
tab={}
for i=1,#self.data do
if string.sub(self.data,i,i)=='1' then
table.insert(tab,'0')
else
table.insert(tab,'1')
end
end
self.data=table.concat(tab)
end
function bits:tobytes()
local tab={}
for i=self:getbytes(),1,-1 do
table.insert(tab,string.char(self:tonumber(i)))
end
return bin.new(table.concat(tab))
end
function bits:toSbytes()
local tab={}
for i=self:getbytes(),1,-1 do
table.insert(tab,string.char(self:tonumber(i)))
end
return table.concat(tab)
end
function bits:getBin()
return self.data
end
function bits:getbytes()
return #self.data/8
end
return bits

244
game/bin/numbers/infinabits.lua Normal file
View File

@ -0,0 +1,244 @@
local binNum=require("bin.numbers.BigNum")
local infinabits={}
infinabits.data=''
infinabits.t='infinabits'
infinabits.Type='infinabits'
infinabits.__index = infinabits
infinabits.__tostring=function(self) return self.data end
infinabits.__len=function(self) return (#self.data)/8 end
local floor,insert = math.floor, table.insert
function basen(n,b)
n=BigNum.new(n)
if not b or b == 10 then return tostring(n) end
local digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
local t = {}
local sign = ""
if n < BigNum.new(0) then
sign = "-"
n = -n
end
repeat
local d = tonumber(tostring(n % b)) + 1
n = n / b
insert(t, 1, digits:sub(d,d))
until n == BigNum.new(0)
return sign .. table.concat(t,"")
end
function base2to10(num)
local n=BigNum.new(0)
for i = #num-1,0,-1 do
nn=BigNum.new(num:sub(i+1,i+1))*(BigNum.new(2)^((#num-i)-1))
n=n+nn
end
return n
end
function infinabits.newBitBuffer(n)
-- WIP
end
function infinabits.newConverter(bitsIn,bitsOut)
local c={}
-- WIP
end
infinabits.ref={}
function infinabits.newByte(d)-- WIP
local c={}
if type(d)=="string" then
if #d>1 or #d<1 then
error("A byte must be one character!")
else
c.data=string.byte(d)
end
elseif type(d)=="number" then
if d>255 or d<0 then
error("A byte must be between 0 and 255!")
else
c.data=d
end
else
error("cannot use type "..type(d).." as an argument! Takes only strings or numbers!")
end
c.__index=function(self,k)
if k>=0 and k<9 then
if self.data==0 then
return 0
elseif self.data==255 then
return 1
else
return infinabits.ref[self.data][k]
end
end
end
c.__tostring=function(self)
return infinabits.ref[tostring(self.data)]
end
setmetatable(c,c)
return c
end
function infinabits.newByteArray(s)-- WIP
local c={}
if type(s)~="string" then
error("Must be a string type or bin/buffer type")
elseif type(s)=="table" then
if s.t=="sink" or s.t=="buffer" or s.t=="bin" then
local data=s:getData()
for i=1,#data do
c[#c+1]=infinabits.newByte(data:sub(i,i))
end
else
error("Must be a string type or bin/buffer type")
end
else
for i=1,#s do
c[#c+1]=infinabits.newByte(s:sub(i,i))
end
end
return c
end
function infinabits.new(n,binary)
local temp={}
temp.t="infinabits"
temp.Type="infinabits"
if type(n)=="string" then
if binary then
temp.data=n:match("[10]+")
else
local t={}
for i=#n,1,-1 do
table.insert(t,infinabits:conv(string.byte(n,i)))
end
temp.data=table.concat(t)
end
elseif type(n)=="number" or type(n)=="table" then
temp.data=basen(tostring(n),2)
end
if #temp.data%8~=0 then
temp.data=string.rep('0',8-#temp.data%8)..temp.data
end
setmetatable(temp, infinabits)
return temp
end
for i=0,255 do
local d=infinabits.new(i).data
infinabits.ref[i]={d:match("(%d)(%d)(%d)(%d)(%d)(%d)(%d)(%d)")}
infinabits.ref[tostring(i)]=d
infinabits.ref[d]=i
infinabits.ref["\255"..string.char(i)]=d
end
function infinabits.numToBytes(n,fit,func)
local num=string.reverse(infinabits.new(BigNum.new(n)):toSbytes())
local ref={["num"]=num,["fit"]=fit}
if fit then
if fit<#num then
if func then
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
func(ref)
else
print("Warning: attempting to store a number that takes up more space than allotted!")
end
return ref.num:sub(1,ref.fit)
elseif fit==#num then
return string.reverse(num)
else
return string.reverse(string.rep("\0",fit-#num)..num)
end
else
return string.reverse(num)
end
end
function infinabits.numToBytes(n,fit,fmt,func)
if fmt=="%e" then
local num=string.reverse(infinabits.new(BigNum.new(n)):toSbytes())
local ref={["num"]=num,["fit"]=fit}
if fit then
if fit<#num then
if func then
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
func(ref)
else
print("Warning: attempting to store a number that takes up more space than allotted!")
end
return ref.num:sub(1,ref.fit)
elseif fit==#num then
return num
else
return string.rep("\0",fit-#num)..num
end
else
return num
end
else
local num=string.reverse(infinabits.new(BigNum.new(n)):toSbytes())
local ref={["num"]=num,["fit"]=fit}
if fit then
if fit<#num then
if func then
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
func(ref)
else
print("Warning: attempting to store a number that takes up more space than allotted!")
end
return ref.num:sub(1,ref.fit)
elseif fit==#num then
return string.reverse(num)
else
return string.reverse(string.rep("\0",fit-#num)..num)
end
else
return string.reverse(num)
end
end
end
function infinabits:conv(n)
local tab={}
local one=BigNum.new(1)
local n=BigNum.new(n)
while n>=one do
table.insert(tab,tonumber(tostring(n%2)))
n=n/2
end
local str=string.reverse(table.concat(tab))
if #str%8~=0 or #str==0 then
str=string.rep('0',8-#str%8)..str
end
return str
end
function infinabits:tonumber(s)
if s==0 then
return tonumber(self.data,2)
end
s=s or 1
return tonumber(tostring(base2to10(string.sub(self.data,(8*(s-1))+1,8*s)))) or error('Bounds!')
end
function infinabits:isover()
return #self.data>8
end
function infinabits:flipbits()
tab={}
local s=self.data
s=s:gsub("1","_")
s=s:gsub("0","1")
s=s:gsub("_","0")
self.data=s
end
function infinabits:tobytes()
local tab={}
for i=self:getbytes(),1,-1 do
table.insert(tab,string.char(self:tonumber(i)))
end
return bin.new(table.concat(tab))
end
function infinabits:toSbytes()
local tab={}
for i=self:getbytes(),1,-1 do
table.insert(tab,string.char(self:tonumber(i)))
end
return table.concat(tab)
end
function infinabits:getBin()
return self.data
end
function infinabits:getbytes()
return #self.data/8
end
return infinabits

333
game/bin/numbers/no_jit_bit.lua Normal file
View File

@ -0,0 +1,333 @@
--[[
LICENSE
(c) 2008-2011 David Manura. Licensed under the same terms as Lua (MIT).
--]]
local M = {_TYPE='module', _NAME='bit.numberlua', _VERSION='0.3.1.20120131'}
local floor = math.floor
local MOD = 2^32
local MODM = MOD-1
local function memoize(f)
local mt = {}
local t = setmetatable({}, mt)
function mt:__index(k)
local v = f(k); t[k] = v
return v
end
return t
end
local function make_bitop_uncached(t, m)
local function bitop(a, b)
local res,p = 0,1
while a ~= 0 and b ~= 0 do
local am, bm = a%m, b%m
res = res + t[am][bm]*p
a = (a - am) / m
b = (b - bm) / m
p = p*m
end
res = res + (a+b)*p
return res
end
return bitop
end
local function make_bitop(t)
local op1 = make_bitop_uncached(t,2^1)
local op2 = memoize(function(a)
return memoize(function(b)
return op1(a, b)
end)
end)
return make_bitop_uncached(op2, 2^(t.n or 1))
end
-- ok? probably not if running on a 32-bit int Lua number type platform
function M.tobit(x)
return x % 2^32
end
M.bxor = make_bitop {[0]={[0]=0,[1]=1},[1]={[0]=1,[1]=0}, n=4}
local bxor = M.bxor
function M.bnot(a) return MODM - a end
local bnot = M.bnot
function M.band(a,b) return ((a+b) - bxor(a,b))/2 end
local band = M.band
function M.bor(a,b) return MODM - band(MODM - a, MODM - b) end
local bor = M.bor
local lshift, rshift -- forward declare
function M.rshift(a,disp) -- Lua5.2 insipred
if disp < 0 then return lshift(a,-disp) end
return floor(a % 2^32 / 2^disp)
end
rshift = M.rshift
function M.lshift(a,disp) -- Lua5.2 inspired
if disp < 0 then return rshift(a,-disp) end
return (a * 2^disp) % 2^32
end
lshift = M.lshift
function M.tohex(x, n) -- BitOp style
n = n or 8
local up
if n <= 0 then
if n == 0 then return '' end
up = true
n = - n
end
x = band(x, 16^n-1)
return ('%0'..n..(up and 'X' or 'x')):format(x)
end
local tohex = M.tohex
function M.extract(n, field, width) -- Lua5.2 inspired
width = width or 1
return band(rshift(n, field), 2^width-1)
end
local extract = M.extract
function M.replace(n, v, field, width) -- Lua5.2 inspired
width = width or 1
local mask1 = 2^width-1
v = band(v, mask1) -- required by spec?
local mask = bnot(lshift(mask1, field))
return band(n, mask) + lshift(v, field)
end
local replace = M.replace
function M.bswap(x) -- BitOp style
local a = band(x, 0xff); x = rshift(x, 8)
local b = band(x, 0xff); x = rshift(x, 8)
local c = band(x, 0xff); x = rshift(x, 8)
local d = band(x, 0xff)
return lshift(lshift(lshift(a, 8) + b, 8) + c, 8) + d
end
local bswap = M.bswap
function M.rrotate(x, disp) -- Lua5.2 inspired
disp = disp % 32
local low = band(x, 2^disp-1)
return rshift(x, disp) + lshift(low, 32-disp)
end
local rrotate = M.rrotate
function M.lrotate(x, disp) -- Lua5.2 inspired
return rrotate(x, -disp)
end
local lrotate = M.lrotate
M.rol = M.lrotate -- LuaOp inspired
M.ror = M.rrotate -- LuaOp insipred
function M.arshift(x, disp) -- Lua5.2 inspired
local z = rshift(x, disp)
if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
return z
end
local arshift = M.arshift
function M.btest(x, y) -- Lua5.2 inspired
return band(x, y) ~= 0
end
M.bit32 = {} -- Lua 5.2 'bit32' compatibility
local function bit32_bnot(x)
return (-1 - x) % MOD
end
M.bit32.bnot = bit32_bnot
local function bit32_bxor(a, b, c, ...)
local z
if b then
a = a % MOD
b = b % MOD
z = bxor(a, b)
if c then
z = bit32_bxor(z, c, ...)
end
return z
elseif a then
return a % MOD
else
return 0
end
end
M.bit32.bxor = bit32_bxor
local function bit32_band(a, b, c, ...)
local z
if b then
a = a % MOD
b = b % MOD
z = ((a+b) - bxor(a,b)) / 2
if c then
z = bit32_band(z, c, ...)
end
return z
elseif a then
return a % MOD
else
return MODM
end
end
M.bit32.band = bit32_band
local function bit32_bor(a, b, c, ...)
local z
if b then
a = a % MOD
b = b % MOD
z = MODM - band(MODM - a, MODM - b)
if c then
z = bit32_bor(z, c, ...)
end
return z
elseif a then
return a % MOD
else
return 0
end
end
M.bit32.bor = bit32_bor
function M.bit32.btest(...)
return bit32_band(...) ~= 0
end
function M.bit32.lrotate(x, disp)
return lrotate(x % MOD, disp)
end
function M.bit32.rrotate(x, disp)
return rrotate(x % MOD, disp)
end
function M.bit32.lshift(x,disp)
if disp > 31 or disp < -31 then return 0 end
return lshift(x % MOD, disp)
end
function M.bit32.rshift(x,disp)
if disp > 31 or disp < -31 then return 0 end
return rshift(x % MOD, disp)
end
function M.bit32.arshift(x,disp)
x = x % MOD
if disp >= 0 then
if disp > 31 then
return (x >= 0x80000000) and MODM or 0
else
local z = rshift(x, disp)
if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
return z
end
else
return lshift(x, -disp)
end
end
function M.bit32.extract(x, field, ...)
local width = ... or 1
if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
x = x % MOD
return extract(x, field, ...)
end
function M.bit32.replace(x, v, field, ...)
local width = ... or 1
if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
x = x % MOD
v = v % MOD
return replace(x, v, field, ...)
end
M.bit = {} -- LuaBitOp "bit" compatibility
function M.bit.tobit(x)
x = x % MOD
if x >= 0x80000000 then x = x - MOD end
return x
end
local bit_tobit = M.bit.tobit
function M.bit.tohex(x, ...)
return tohex(x % MOD, ...)
end
function M.bit.bnot(x)
return bit_tobit(bnot(x % MOD))
end
local function bit_bor(a, b, c, ...)
if c then
return bit_bor(bit_bor(a, b), c, ...)
elseif b then
return bit_tobit(bor(a % MOD, b % MOD))
else
return bit_tobit(a)
end
end
M.bit.bor = bit_bor
local function bit_band(a, b, c, ...)
if c then
return bit_band(bit_band(a, b), c, ...)
elseif b then
return bit_tobit(band(a % MOD, b % MOD))
else
return bit_tobit(a)
end
end
M.bit.band = bit_band
local function bit_bxor(a, b, c, ...)
if c then
return bit_bxor(bit_bxor(a, b), c, ...)
elseif b then
return bit_tobit(bxor(a % MOD, b % MOD))
else
return bit_tobit(a)
end
end
M.bit.bxor = bit_bxor
function M.bit.lshift(x, n)
return bit_tobit(lshift(x % MOD, n % 32))
end
function M.bit.rshift(x, n)
return bit_tobit(rshift(x % MOD, n % 32))
end
function M.bit.arshift(x, n)
return bit_tobit(arshift(x % MOD, n % 32))
end
function M.bit.rol(x, n)
return bit_tobit(lrotate(x % MOD, n % 32))
end
function M.bit.ror(x, n)
return bit_tobit(rrotate(x % MOD, n % 32))
end
function M.bit.bswap(x)
return bit_tobit(bswap(x % MOD))
end
return M

232
game/bin/numbers/random.lua Normal file
View File

@ -0,0 +1,232 @@
--[[----------------------------------------
Random
Not all of this is mine
------------------------------------------]]
--[[------------------------------------
RandomLua v0.3.1
Pure Lua Pseudo-Random Numbers Generator
Under the MIT license.
copyright(c) 2011 linux-man
--]]------------------------------------
local math_floor = math.floor
local function normalize(n)
return n % 0x80000000
end
local function bit_and(a, b)
local r = 0
local m = 0
for m = 0, 31 do
if (a % 2 == 1) and (b % 2 == 1) then r = r + 2^m end
if a % 2 ~= 0 then a = a - 1 end
if b % 2 ~= 0 then b = b - 1 end
a = a / 2 b = b / 2
end
return normalize(r)
end
local function bit_or(a, b)
local r = 0
local m = 0
for m = 0, 31 do
if (a % 2 == 1) or (b % 2 == 1) then r = r + 2^m end
if a % 2 ~= 0 then a = a - 1 end
if b % 2 ~= 0 then b = b - 1 end
a = a / 2 b = b / 2
end
return normalize(r)
end
local function bit_xor(a, b)
local r = 0
local m = 0
for m = 0, 31 do
if a % 2 ~= b % 2 then r = r + 2^m end
if a % 2 ~= 0 then a = a - 1 end
if b % 2 ~= 0 then b = b - 1 end
a = a / 2 b = b / 2
end
return normalize(r)
end
local function seed()
return normalize(os.time())
end
--Mersenne twister
local mersenne_twister = {}
mersenne_twister.__index = mersenne_twister
function mersenne_twister:randomseed(s)
if not s then s = seed() end
self.mt[0] = normalize(s)
for i = 1, 623 do
self.mt[i] = normalize(0x6c078965 * bit_xor(self.mt[i-1], math_floor(self.mt[i-1] / 0x40000000)) + i)
end
end
function mersenne_twister:random(a, b)
local y
if self.index == 0 then
for i = 0, 623 do
y = self.mt[(i + 1) % 624] % 0x80000000
self.mt[i] = bit_xor(self.mt[(i + 397) % 624], math_floor(y / 2))
if y % 2 ~= 0 then self.mt[i] = bit_xor(self.mt[i], 0x9908b0df) end
end
end
y = self.mt[self.index]
y = bit_xor(y, math_floor(y / 0x800))
y = bit_xor(y, bit_and(normalize(y * 0x80), 0x9d2c5680))
y = bit_xor(y, bit_and(normalize(y * 0x8000), 0xefc60000))
y = bit_xor(y, math_floor(y / 0x40000))
self.index = (self.index + 1) % 624
if not a then return y / 0x80000000
elseif not b then
if a == 0 then return y
else return 1 + (y % a)
end
else
return a + (y % (b - a + 1))
end
end
local function twister(s)
local temp = {}
setmetatable(temp, mersenne_twister)
temp.mt = {}
temp.index = 0
temp:randomseed(s)
return temp
end
--Linear Congruential Generator
local linear_congruential_generator = {}
linear_congruential_generator.__index = linear_congruential_generator
function linear_congruential_generator:random(a, b)
local y = (self.a * self.x + self.c) % self.m
self.x = y
if not a then return y / 0x10000
elseif not b then
if a == 0 then return y
else return 1 + (y % a) end
else
return a + (y % (b - a + 1))
end
end
function linear_congruential_generator:randomseed(s)
if not s then s = seed() end
self.x = normalize(s)
end
local function lcg(s, r)
local temp = {}
setmetatable(temp, linear_congruential_generator)
temp.a, temp.c, temp.m = 1103515245, 12345, 0x10000 --from Ansi C
if r then
if r == 'nr' then temp.a, temp.c, temp.m = 1664525, 1013904223, 0x10000 --from Numerical Recipes.
elseif r == 'mvc' then temp.a, temp.c, temp.m = 214013, 2531011, 0x10000 end--from MVC
end
temp:randomseed(s)
return temp
end
-- Multiply-with-carry
local multiply_with_carry = {}
multiply_with_carry.__index = multiply_with_carry
function multiply_with_carry:random(a, b)
local m = self.m
local t = self.a * self.x + self.c
local y = t % m
self.x = y
self.c = math_floor(t / m)
if not a then return y / 0x10000
elseif not b then
if a == 0 then return y
else return 1 + (y % a) end
else
return a + (y % (b - a + 1))
end
end
function multiply_with_carry:randomseed(s)
if not s then s = seed() end
self.c = self.ic
self.x = normalize(s)
end
local function mwc(s, r)
local temp = {}
setmetatable(temp, multiply_with_carry)
temp.a, temp.c, temp.m = 1103515245, 12345, 0x10000 --from Ansi C
if r then
if r == 'nr' then temp.a, temp.c, temp.m = 1664525, 1013904223, 0x10000 --from Numerical Recipes.
elseif r == 'mvc' then temp.a, temp.c, temp.m = 214013, 2531011, 0x10000 end--from MVC
end
temp.ic = temp.c
temp:randomseed(s)
return temp
end
-- Little bind for the methods: My code starts
local randomGen={}
randomGen.__index=randomGen
function randomGen:new(s)
local temp={}
setmetatable(temp,randomGen)
temp[1]=twister()
temp[2]=lcg()
temp[3]=mwc()
temp.pos=1
for i=1,3 do
temp[i]:randomseed(s)
end
return temp
end
function randomGen:randomseed(s)
self.pos=1
self[1]:randomseed(s)
self[2]:randomseed(s)
self[3]:randomseed(s)
end
function randomGen:randomInt(a,b)
local t=self[self.pos]:random(a,b)
self.pos=self.pos+1
if self.pos>3 then
self.pos=1
end
return t
end
function randomGen:newND(a,b,s)
if not(a) or not(b) then error('You must include a range!') end
local temp=randomGen:new(s)
temp.a=a
temp.b=b
temp.range=b-a+1
temp.dups={no=0}
function temp:nextInt()
local t=self:randomInt(self.a,self.b)
if self.dups[t]==nil then
self.dups[t]=true
self.dups.no=self.dups.no+1
else
return self:nextInt()
end
if self.dups.no==self.range then
function self:nextInt()
return 1,true
end
return t
else
return t
end
end
function temp:nextIInt()
return function() return self:nextInt() end
end
return temp
end
return randomGen

Some files were not shown because too many files have changed in this diff Show More