fusion 1 ecran

local computer = require("computer")
local component = require("component")
local term = require("term")
local math = require("math")
local event = require("event")
local string = require("string")
local unicode = require("unicode")
local color = require("colors")
local side = require("sides")
local serialization = require("serialization")

--Récupération écran et GPU
local screen = component.getPrimary("screen")
local gpu = component.gpu
gpu.setResolution(100,50)

--définition des couleurs
local noir = 0x000000
local blanc = 0xFFFFFF
local rouge = 0xFF0000
local vert = 0x00FF00
local bleu = 0x0000FF
local cyan = 0x00FFFF
local jaune = 0xFFFF00
local magenta = 0xFF00FF
local violet = 0xBE00FF
local orange = 0xFF9143

--Récupération des composants
local rs = component.redstone
local fusion = component.reactor_logic_adapter
local laser1 = component.getPrimary("laser_amplifier")
local cmd = side.top
local DTf = side.east
local alm = side.bottom
local tank_tritium = component.proxy(component.get("0351","tank_controller"))
local tank_deuterium = component.proxy(component.get("3cff","tank_controller"))
local tank_dtf = component.proxy(component.get("0057","tank_controller"))
local tank = {{tank_tritium,color=bleu},{tank_deuterium,color=rouge},{tank_dtf,color=violet}}

--définition des variables
local lancement = 1000000000
local ratio_fusion = 0
local alim_fusion_dtfuel_value = 0
local etape_demarrage = 0
local decompte_max = 10
local decompte = decompte_max
local table_bit = {
  false, -- 1 charge_laser
  false, -- 2 charge_laser1
  false, -- 3
  false, -- 4 alim_fusion
  false, -- 5 alim_fusion_tritium
  false, -- 6 alim_fusion_deuterium
  false, -- 7 alim_cuve_dtfuel
  false, -- 8
  false, -- 9 activation_laser_amplifier
  false, -- 10 alarmes activées/désactivées
  false, -- 11 alim_dtfuel_tritium
  false, -- 12 alim_dtfuel_deuterium
  false, -- 13 laser chargés
  false, -- 14 démarrage auto
  false, -- 15
  false --
}
local table_rotary = {}
local i = 0
for i = 0, 12 do
  local text = "Rotary n°"..tostring(i)
  local v1 = false
  table_rotary[i] = {label=text,bit=v1}
end
local etat_rs = false
local etat_rs2 = false
local buzz = {false,false,false,false,false,false,false,false}

--initialisation de la redstone
for i = 0, 15 do
rs.setBundledOutput(cmd,i,255)
rs.setBundledOutput(DTf,i,255)
end


--Fonctions
local function setColor(bg,fg)
  gpu.setBackground(bg)
  gpu.setForeground(fg)
end

 local function unit(qty)
  if qty >= 1000000000 then
    return string.format("%.02f MB",qty/10000000)
  elseif qty >=1000000 then
    return string.format("%.02f KB",qty/1000000)
  elseif qty >=1000 then
    return string.format("%.02f B ",qty/1000)
  else
    return string.format("%d mB",qty)
  end
end

local function unitrf(qty)
  if qty >= 1000000000000000 or qty <= -1000000000000000 then
    return string.format("%.03f PRF",qty/1000000000000000)
  elseif qty >= 1000000000000 or qty <= -1000000000000 then
    return string.format("%.03f TRF",qty/1000000000000)
  elseif qty >=1000000000 or qty <= -1000000000 then
    return string.format("%.03f GRF",qty/1000000000)
  elseif qty >=1000000 or qty <= -1000000 then
    return string.format("%.03f MRF",qty/1000000)
  elseif qty >=1000 or qty <= -1000 then
    return string.format("%.03f kRF",qty/1000)
  else
    return string.format("%.03f RF ",qty)
  end
end

 local function unitdeg(qty)
  if qty >= 1000000000000000 then
    return string.format("%.01fP°",qty/10000000000000)
  elseif qty >= 1000000000000 then
    return string.format("%.01fT°",qty/10000000000)
  elseif qty >= 1000000000 then
    return string.format("%.01fG°",qty/10000000)
  elseif qty >=1000000 then
    return string.format("%.01fM°",qty/1000000)
  elseif qty >=1000 then
    return string.format("%.01fK° ",qty/1000)
  else
    return string.format("%d°",qty)
  end
end

function loadbar(x,y,width,cur,text,bg,fg)
  local raw = " " .. text ..string.rep(" ", width - unicode.len(text) - 2) .. " "
  local oldbg = gpu.setBackground(bg)
  local oldfg = gpu.setForeground(fg)
  gpu.set(x,y,unicode.sub(raw,1,cur))
  gpu.setBackground(oldbg)
  gpu.setForeground(oldfg)
  gpu.set(x+cur,y,unicode.sub(raw,cur+1,width))
end

local function affenergie(x,y,length,tableau)
  local amount = tableau[1] * 0.4
  local capacity = tableau[2] * 0.4
  local pct = amount / capacity
  local color = cyan
  local color2 = rouge
  local cur = math.floor(pct * length)
  local textfrac = string.format("%s / %s", unitrf(amount), unitrf(capacity))
  local textpct = string.format("%.02f%%", pct*100)
  local text1 = "        ENERGIE DANS LA BATTERIE MEKANISM "
  local text2 = textfrac .. string.rep(" ", length - string.len(textfrac) - string.len(textpct) - 2) .. textpct
  loadbar(x,y,length,cur,text1,color,color2)
  loadbar(x,y+1,length,cur,text2,color,color2)
end

local function afflaser(x,y,length,nlaser)
  local amount = laser[nlaser].getEnergy() * 0.4
  local capacity = laser[nlaser].getMaxEnergy() * 0.4
  local pct = amount / capacity
  local color = bleu
  local color2 = jaune
  local cur = math.floor(pct * length)
  local textfrac = string.format("%s / %s", unitrf(amount), unitrf(capacity))
  local textpct = string.format("%.02f%%", pct*100)
  local texte_laser1
  local texte_laser2
  if amount == capacity then
    texte_laser1 = "Chargé totalement"
    table_bit[nlaser] = false
  elseif table_bit[1] == false then
    texte_laser1 = "En attente de charge"
  elseif table_bit[1] == true then
    if table_bit[nlaser] == false then
      texte_laser1 = "En attente de charge"
    else
      texte_laser1 = "En  charge"
    end
  end
  if amount < lancement then
    texte_laser2 = " - Lancement impossible"
  elseif amount >= lancement then
    texte_laser2 = " - Lancement possible"
  end
  texte_palier = "│  Palier de lancement minimum : "..unitrf(lancement)
  local text1 = " Charge du Laser Amplifier n°"..nlaser.." - "..texte_laser1..texte_laser2
  local text2 = textfrac .. string.rep(" ", length - string.len(textfrac) - string.len(textpct) - 2) .. textpct
  loadbar(x,y,length,cur,text1,color,color2)
  loadbar(x,y+1,length,cur,text2,color,color2)
end

local function lvl_dtfuel(x,y,length,ntank)
  local amount = tank[ntank][1].getFluidInTank(0)[1].amount
  local capacity = tank[ntank][1].getFluidInTank(0)[1].capacity
  local pct = amount / capacity
  local cur = math.floor(pct * length)
  local bg = tank[ntank].color
  local fg = blanc - bg
  local text = ntank.." : "..string.format("%06.02f%%",pct)
  loadbar(x,y,length,cur,text,bg,fg)
  loadbar(x,y+1,length,cur,text,bg,fg)
end

local function barre_verticale(x,y,hauteur,largeur,entete,ntank,color1,color2)
  local k = 0
  local amount = tank[ntank][1].getFluidInTank(0)[1].amount
  local capacity = tank[ntank][1].getFluidInTank(0)[1].capacity
  local cur = math.floor((amount / capacity) * hauteur)
  local dir = string.rep(" ",largeur)
  for k = 1, hauteur do
    local vy = y + hauteur - k
    if k <= cur then
      setColor(color1,color2)
    elseif k > cur then
      setColor(noir,blanc)
    end
      gpu.set(x,vy,dir)
    if k == 1 then
      gpu.set(x,vy,dir)
      gpu.set(x,vy,"  Max "..unit(capacity))
    elseif k == 3 then
      gpu.set(x,vy,dir)
      gpu.set(x,vy,"  Cur "..unit(amount))
    elseif k == 4 then
      gpu.set(x,vy,dir)
      gpu.set(x,vy,string.format("  Cur %06.02f%%  ",(amount/capacity)*100))
    elseif k == hauteur then
      gpu.set(x,vy,entete)
    end
    setColor(noir,blanc)
  end
end

local function bouton(x,y,etat,text,color,color2)
  if etat == true then
    setColor(color,color2)
    gpu.set(x,y," "..text.." ")
    setColor(noir,blanc)
  elseif etat == false then
    setColor(color2,color)
    gpu.set(x,y," "..text.." ")
    setColor(noir,blanc)
  end
end

local function bouton_rotary(x,y,netat)
  local text
    if table_rotary[netat].bit == true then
      text = "ON "
      bouton(x,y,table_rotary[netat].bit,text,vert,noir)
      setColor(bleu,jaune)
      gpu.set(2+netat*3,8,netat)
      setColor(noir,blanc)
    elseif table_rotary[netat].bit == false then
      text = "OFF"
      bouton(x,y,table_rotary[netat].bit,text,rouge,noir)
      setColor(rouge,cyan)
      gpu.set(2+netat*2,8,netat)
      setColor(noir,blanc)
    end
end

local function boutonx2(x,y,x2,y2,nbit,text1,text2,color1,color2,color3,color4,espace)
  if x2 > x-1 and x2 < x+string.len(text1)+2 and y2 == y then
    table_bit[nbit] = true
  elseif x2 > x+string.len(text1)+2 and x2 < x+string.len(text1)+string.len(text2)+5 and y2 == y then
    table_bit[nbit] = false
  end
  bouton(x,y,table_bit[nbit],text1,color1,color2)
  bouton(x+string.len(text1)+2+espace,y,not(table_bit[nbit]),text2,color3,color4)
end

local function bouton_vanne(x,y,x2,y2,nbit)
  if x2 > x-1 and x2 < x+5 and y > y-1 and y < y+4 then
    if table_bit[nbit] == false then
      table_bit[nbit] = true
    elseif table_bit[nbit] == true then
      table_bit[nbit] = false
    end
  end
  if table_bit[nbit] == true then
    bouton(x,y,table_bit[nbit],"ON ",vert,noir)
    setColor(noir,vert)
    gpu.set(x+2,y+1," ")
    gpu.set(x,y+2,"═════")
    gpu.set(x+2,y+3," ")
  elseif table_bit[nbit] == false then
    bouton(x,y,table_bit[nbit],"OFF",noir,rouge)
    setColor(noir,rouge)
    gpu.set(x+2,y+1,"║")
    gpu.set(x,y+2,"  ║  ")
    gpu.set(x+2,y+3,"║")
  end
  setColor(noir,blanc)
end

local function afflasers(x,y,length)
  afflaser(x,y,length,1)
  afflaser(x,y+3,length,2)
end

local function conversion_binaire_nombre(etat)
  if etat == false then
    return 255
  elseif etat == true then
    return 0
  end
end

local function conversion_nombre_binaire(etat)
  if etat == 0 then
    return true
  elseif etat > 0 then
    return false
  end
end

local function ctrl_fusion(x,y)
  local width_case = 22
  local width_plasma = 20
  local width_energy = 22
  local color1_case = 0xff5b43
  local color2_case = blanc - color1_case
  local color1_plasma = 0xfdffbf
  local color2_plasma = blanc - color1_plasma
  local color1_energy = 0x5fff3b
  local color2_energy = blanc - color1_energy

  local case_heat = fusion.getCaseHeat()
  local max_case_heat
  local cur_case
  if table_bit[4] == true then
    max_case_heat = 5000
  elseif table_bit[4] == false then
    max_case_heat = fusion.getMaxCaseHeat()
  end
  if max_case_heat == 0 then
    cur_case = math.floor(case_heat / 5000 * width_case)
  else
    cur_case = math.floor(case_heat / max_case_heat * width_case)
  end
  local text1_case = "  Case heat   "
  local text2_case = unitdeg(case_heat).." / "..unitdeg(max_case_heat)
  loadbar(x,y-2,width_case,cur_case,text1_case,color1_case,color2_case)
  loadbar(x,y-1,width_case,cur_case,text2_case,color1_case,color2_case)

  local plasma_heat = fusion.getPlasmaHeat()
  local max_plasma_heat
  local cur_plasma
  if table_bit[4] == true then
    max_plasma_heat = 7500
  elseif table_bit[4] == false then
    max_plasma_heat = fusion.getMaxPlasmaHeat()
  end
  if max_plasma_heat == 0 then
    cur_plasma = math.floor(plasma_heat / 7500 * width_plasma)
  else
    cur_plasma = math.floor(plasma_heat / max_plasma_heat * width_plasma)
  end
  local text1_plasma = "  Temp. plasma  "
  local text2_plasma = unitdeg(plasma_heat).." / "..unitdeg(max_plasma_heat)
  loadbar(x+1,y-4,width_plasma,cur_plasma,text1_plasma,color1_plasma,color2_plasma)
  loadbar(x+1,y-3,width_plasma,cur_plasma,text2_plasma,color1_plasma,color2_plasma)
  gpu.set(x+1,y-4,"/")
  gpu.set(x+20,y-4,[[\]])

  local energy = fusion.getEnergy() * 0.4
  local max_energy = fusion.getMaxEnergy() * 0.4
  local cur_energy = math.floor(energy / max_energy * width_energy)
  local text1_energy = "   Energie stockée    "
  local text2_energy = unitrf(energy).." / "..string.format("%d GRF",max_energy/1000000000)
  loadbar(x,y+1,width_energy,cur_energy,text1_energy,color1_energy,color2_energy)
  loadbar(x,y+2,width_energy,cur_energy,text2_energy,color1_energy,color2_energy)

  if fusion.canIgnite() == true then
    setColor(noir,vert)
    gpu.set(x,y,"    Réacteur prêt     ")
  elseif fusion.canIgnite() == false then
    setColor(noir,rouge)
    gpu.set(x,y," Réacteur en attente  ")

  end
  rs.setBundledOutput(cmd,9,conversion_binaire_nombre(fusion.canIgnite()))
end

local function affrotaryx12(x,y)
print("a")
  if etat_rs ~= etat_rs2 then
print("b")
    local i
    gpu.set(30,8,tostring(test))
    for i = 0, 11 do
      if i <= 5 then
        bouton_rotary(x-8*(i),15,i)
      elseif i > 5 and i <= 11 then
        bouton_rotary(x-8*(i-6),39,i)
      end
    end
print("c")
    etat_rs2 = etat_rs
print("d")
  end
print("y")
end

local function aff_pourcent()
  setColor(bleu,blanc)
  local alim_pct = alim_fusion_dtfuel_value / 24
  gpu.set(26,22,string.format("% 6.02f%%", alim_pct*100))
  setColor(noir,blanc)
  if table_bit[4] == false then
    setColor(orange,noir)
    gpu.set(48,31,string.format("% 6d", fusion.getInjectionRate()))
    setColor(noir,blanc)
  elseif table_bit[4] == true then
    gpu.set(48,31,"-------")
    fusion.setInjectionRate(0)
  end
end

local function cmd_rotary()
local i
  for i = 0, 24 do
    if i < alim_fusion_dtfuel_value then
      if i < 12 then
        rs.setBundledOutput(DTg,i,0)
        table_rotary[i].bit = true
      elseif i >= 12 then
        rs.setBundledOutput(DTd,i-12,0)
        table_rotary[i+12].bit = true
      end
    elseif i >= alim_fusion_dtfuel_value then
      if i < 12 then
        rs.setBundledOutput(DTg,i,255)
        table_rotary[i].bit = false
      elseif i >= 12 then
        rs.setBundledOutput(DTd,i-12,255)
        table_rotary[i+12].bit = false
      end
    end
  end
end

local function start_auto()
  if table_bit[14] == true and etape_demarrage == 0 and fusion.isIgnited() == false then
    buzzer(0,255)
    decompte = decompte - 1
    if decompte == 0 then
      table_bit[1] = true
      etape_demarrage = 1
      buzzer(0,255)
      decompte = decompte_max
    end
  elseif table_bit[14] == false or fusion.isIgnited() == true then
    etape_demarrage = 0
    decompte = decompte_max
  end

  if etape_demarrage == 0 then
    if rs.getBundledOutput(cmd,8) ~= 0 then
      --rs.setBundledOutput(cmd,8,0) = 0
    end
  elseif etape_demarrage == 1 then
    table_bit[1] = true
    if laser[1].getEnergy() * 0.4 < lancement then
      table_bit[2] = true
    else
      table_bit[2]= false
    end
    if laser[2].getEnergy() * 0.4 < lancement then
      table_bit[3] = true
    else
      table_bit[3]= false
    end
    if laser[1].getEnergy() * 0.4 < lancement and laser[2].getEnergy() * 0.4 < lancement then
      etape_demarrage = 2
    end
  elseif etape_demarrage == 2 then
    if table_bit[4] == false then
      ratio_fusion = 2
    elseif table_bit[4] == true then
      alim_fusion_dtfuel_value = 1
    end
    etape_demarrage = 3

  elseif etape_demarrage == 3 then
    buzzer(1,255)
    decompte = decompte - 1
    if decompte == 0 then
      rs.setBundledOutput(cmd,8,255)
      etape_demarrage = 0
      buzzer(1,255)
      decompte = decompte_max
    end
  end
end

local function buzzer(nbuzzer,value)
  rs.setBundledOutput(alm,nbuzzer,value)
end

local function binaire_redstone()
  rs.setBundledOutput(cmd,0,conversion_binaire_nombre(table_bit[2]))  -- laser gauche
  --rs.setBundledOutput(cmd,1,conversion_binaire_nombre()  --
  rs.setBundledOutput(cmd,2,conversion_binaire_nombre(table_bit[6]))  -- alim fusion en deutérium
  rs.setBundledOutput(cmd,3,conversion_binaire_nombre(table_bit[5]))  -- alim fusion en tritium
  rs.setBundledOutput(cmd,4,conversion_binaire_nombre(table_bit[4]))  -- alim fusion dt-fuel ou deut-trit
  rs.setBundledOutput(cmd,5,conversion_binaire_nombre(not(table_bit[4])))  -- alim fusion dt-fuel ou deut-trit
  rs.setBundledOutput(cmd,6,conversion_binaire_nombre(table_bit[7]))  -- alim cuve gauche dt-fuel
  --rs.setBundledOutput(cmd,7,conversion_binaire_nombre()  --
  rs.setBundledOutput(cmd,11,conversion_binaire_nombre(table_bit[11]))  -- alim machinerie dt-fuel en tritium
  --rs.setBundledOutput(cmd,12,conversion_binaire_nombre())  --
  --rs.setBundledOutput(cmd,13,conversion_binaire_nombre())  --
  rs.setBundledOutput(cmd,14,conversion_binaire_nombre(table_bit[12]))  -- alim machinerie dt-fuel en deutérium
  --rs.setBundledOutput(cmd,15,conversion_binaire_nombre())  --
end

local function affboutons(x,y)
  boutonx2(62,43,x,y,1,"ON","OFF",vert,noir,rouge,noir,1)
  boutonx2(24,32,x,y,2,"ON","OFF",vert,noir,rouge,noir,2)
  boutonx2(67,32,x,y,3,"ON","OFF",vert,noir,rouge,noir,2)
  boutonx2(20,43,x,y,4,"D-T Fuel","Deutérium-Tritium",violet,noir,jaune,noir,1)
  boutonx2(87,43,x,y,10,"ON","OFF",vert,noir,rouge,noir,2)
  boutonx2(4,9,x,y,14,"ON","OFF",vert,noir,rouge,noir,2)
  bouton_vanne(29,24,x,y,5)
  bouton_vanne(68,24,x,y,6)
  aff_pourcent()
  binaire_redstone()
end

--Matrices
"z")
affboutons(2,1)

local function onTouch(event,address,x,y,clic,pseudo)
  local tclic
  if clic == 0  then
    tclic = "Clic gauche"
  elseif clic == 1 then
    tclic = "Clic droit"
  else
    tclic = "Clic inconnu"
  end
  gpu.set(2,2,"                                                                                                  ")
  gpu.set(5,2," "..tclic.." de la part de "..pseudo.." / X : "..string.format("% 3s",x).." / Y : "..string.format("% 3s",y))
  if x~=1 and y~=1 then
    if y==22 then
      if x>22 and x<26 then
        alim_fusion_dtfuel_value = alim_fusion_dtfuel_value + 1
        if alim_fusion_dtfuel_value > 24 then
          alim_fusion_dtfuel_value = 24
        end
      elseif x>32 and x<36 then
        alim_fusion_dtfuel_value = alim_fusion_dtfuel_value - 1
        if alim_fusion_dtfuel_value < 0 then
          alim_fusion_dtfuel_value = 0
        end
      end
    elseif y==34 then
      if x>13 and x<20 then
        ratio_fusion = ratio_fusion - 10000
        if ratio_fusion < 0 then
          ratio_fusion = 0
        end
      elseif x>20 and x<26 then
        ratio_fusion = ratio_fusion - 1000
        if ratio_fusion < 0 then
          ratio_fusion = 0
        end
      elseif x>26 and x<31 then
        ratio_fusion = ratio_fusion - 100
        if ratio_fusion < 0 then
          ratio_fusion = 0
        end
      elseif x>31 and x<35 then
        ratio_fusion = ratio_fusion - 10
        if ratio_fusion < 0 then
          ratio_fusion = 0
        end
      elseif x>35 and x<38 then
        ratio_fusion = ratio_fusion - 2
        if ratio_fusion < 0 then
          ratio_fusion = 0
        end
      elseif x>63 and x<66 then
        ratio_fusion = ratio_fusion + 2
        if ratio_fusion > 100000 then
          ratio_fusion = 100000
        end
      elseif x>66 and x<70 then
        ratio_fusion = ratio_fusion + 10
        if ratio_fusion > 100000 then
          ratio_fusion = 100000
        end
      elseif x>70 and x<75 then
        ratio_fusion = ratio_fusion + 100
        if ratio_fusion > 100000 then
          ratio_fusion = 100000
        end
      elseif x>75 and x<81 then
        ratio_fusion = ratio_fusion + 1000
        if ratio_fusion > 100000 then
          ratio_fusion = 100000
        end
      elseif x>81 and x<88 then
        ratio_fusion = ratio_fusion + 10000
        if ratio_fusion > 100000 then
          ratio_fusion = 100000
        end
      end
      fusion.setInjectionRate(ratio_fusion)
    end
    affboutons(x,y)
  elseif x==1 and y==1 then
    computer.pushSignal("quit")
    term.setCursor(1,1)
    return false
  end
end

local function onTimer(_,timer)
  lvl_dtfuel(65,21,15,3)
  barre_verticale(4,22,11,15,"    TRITIUM    ",3,bleu,jaune)
  barre_verticale(83,22,11,15,"   DEUTERIUM   ",3,rouge,vert)
  afflasers(2,45,98)
  affrotaryx12(44,15)
  ctrl_fusion(40,26)

  return true
end

event.listen("touch",onTouch)
local timer = event.timer(.1,onTimer,math.huge)
event.listen("redstone_changed", onRedstone)
event.pull("quit")
event.cancel(timer)
event.ignore("touch",onTouch)
event.ignore("redstone_changed", onRedstone)

rs.setBundledOutput(cmd,0,conversion_binaire_nombre(false))  -- laser gauche
rs.setBundledOutput(cmd,1,conversion_binaire_nombre(false))  -- laser droite
rs.setBundledOutput(cmd,2,conversion_binaire_nombre(false))  -- alim fusion en deutérium
rs.setBundledOutput(cmd,3,conversion_binaire_nombre(false))  -- alim fusion en tritium
rs.setBundledOutput(cmd,4,conversion_binaire_nombre(false))  -- alim fusion dt-fuel ou deut-trit
rs.setBundledOutput(cmd,5,conversion_binaire_nombre(true))  -- alim fusion dt-fuel ou deut-trit
rs.setBundledOutput(cmd,6,conversion_binaire_nombre(false))  -- alim cuve gauche dt-fuel
rs.setBundledOutput(cmd,7,conversion_binaire_nombre(false))  -- alim cuve droite dt-fuel
rs.setBundledOutput(cmd,8,conversion_binaire_nombre(true))  -- activation laser amplifier - lancement fusion
  --rs.setBundledOutput(cmd,9,)  -- laser_pret activé dans fonction ctrl_fusion
rs.setBundledOutput(cmd,11,conversion_binaire_nombre(false))  -- alim machinerie dt-fuel en tritium
rs.setBundledOutput(cmd,14,conversion_binaire_nombre(false))  -- alim machinerie dt-fuel en deutérium

setColor(noir,blanc)
gpu.setResolution(160,45)
gpu.fill(1,1,160,50," ")

--Créé par sshikamaru. Vous avez le droit de l'utiliser mais pas de le distribuer.