atome 0.5.7.1.0 → 0.5.7.1.4

data/vendor/assets/application/examples/test.rb

@@ -1,584 +1,158 @@
-# frozen_string_literal: true
-
-# grab(:intuition).box({id: :toolbox, left: 33, top: 333})
-# toolbox_style contain all tools styles
-size = 33
-smooth = 3
-shadow({
-         id: :tool_shade,
-         left: 3, top: 3, blur: 3,
-         invert: false,
-         red: 0, green: 0, blue: 0, alpha: 0.6
-       })
-
-color({ id: :tool_inactive_color, red: 1, green: 1, blue: 1, alpha: 0.12 })
-color({ id: :tool_active_color, red: 1, green: 1, blue: 1, alpha: 0.3 })
-border({ id: :tool_box_border, thickness: 1, red: 1, green: 1, blue: 1, alpha: 0.06, pattern: :solid, inside: true })
-# Tool's style object container below
-element({ aid: :toolbox_style, id: :toolbox_style, data: {
-  color: :gray,
-  size: size,
-  smooth: smooth
-} })
-
-class Atome
-  @tools_actions_to_exec = {}
-
-  class << self
-
-    def init_intuition
-      Atome.start_click_analysis
-      Universe.tools.each_with_index do |(tool_name, bloc), index|
-        # puts "add position and orientation"
-        A.build_tool({ name: tool_name, index: index }, &bloc)
-      end
-    end
-
-    def selection
-      grab(Universe.current_user).selection.collect
-    end
-
-    def add_tool_actions(tool_name, tool_content)
-      # alert "tool_content is : tool_content#{tool_content}"
-      # int8_f=tool_content[:int8]
-      # activation_f=tool_content[:active]
-      # inactivation_f=tool_content[:inactive]
-      # creator=tool_content[:creation]
-      # alterator=tool_content[:alteration]
-      @tools_actions_to_exec[tool_name] = tool_content
-    end
-
-    def tool_actions_to_exec
-      @tools_actions_to_exec
-    end
-
-    def activate_click_analysis
-
-      # the condition below avoid touchdown analysis accumulation
-      unless @click_analysis_active
-        # this method analyse all object under the touchdown to find the first user objet and return it's id
-
-        @click_analysis = lambda { |native_event|
-          # the instance variable below check if we can apply tool (cf:  if the atome we don't want to apply tool)
-          if Universe.allow_tool_operations
-            event = Native(native_event)
-            x = event[:clientX]
-            y = event[:clientY]
-            elements = JS.global[:document].elementsFromPoint(x, y)
-            elements.to_a.each do |element|
-              id_found = element[:id].to_s
-              atome_touched = grab(id_found)
-              if grab(id_found) && grab(id_found).tag[:system]
-              else
-                @creations_f = []
-                @alterations_f = []
-                current_tool = ''
-                @tools_actions_to_exec.each do |tool_name, actions|
-                  current_tool = grab(tool_name)
-                  @creations_f = @creations_f.concat(actions[:creation]) if actions[:creation] # Concaténation
-                  @alterations_f = @alterations_f.concat(actions[:alteration]) if actions[:alteration] # Concaténation
-                end
-                # Creation below
-                @creations_f.each do |create_content|
-                  code_before_applying = create_content[:pre]
-                  code_after_applying = create_content[:post]
-                  instance_exec(atome_touched,event,&code_before_applying) if code_before_applying.is_a? Proc
-                  atome_type = create_content[:type]
-                  particles = create_content[:particles]
-                  new_atome = grab(:view).send(atome_type)
-                  particles.each do |particle_found, value_found|
-                    new_atome.send(particle_found, value_found)
-                  end
-                  new_atome.resize(true)
-                  new_atome.drag(true)
-                  new_atome.left(event[:pageX].to_i)
-                  new_atome.top(event[:pageY].to_i)
-                  current_tool.data << new_atome
-                  instance_exec(atome_touched,new_atome,event,&code_after_applying) if code_after_applying.is_a? Proc
-
-                  # now applying alterations on new atome if needed:
-                  @alterations_f.each do |actions_f|
-                    code_before_applying = actions_f[:pre]
-                    code_after_applying = actions_f[:post]
-                    instance_exec(new_atome,event,&code_before_applying) if code_before_applying.is_a? Proc
-                    action = actions_f[:particle]
-                    value = actions_f[:value]
-                    new_atome.send(action, value)
-                    instance_exec(new_atome,event,&code_after_applying) if code_after_applying.is_a? Proc
-                  end
-
-
-                end
-                if atome_touched
-                  @alterations_f.each do |actions_f|
-                    code_before_applying = actions_f[:pre]
-                    code_after_applying = actions_f[:post]
-                    instance_exec(nil,event,&code_before_applying) if code_before_applying.is_a? Proc
-                    action = actions_f[:particle]
-                    value = actions_f[:value]
-                    atome_touched.send(action, value)
-                    instance_exec(nil,event,&code_after_applying) if code_after_applying.is_a? Proc
-                  end
-                  # Atome.instance_exec(id_found, x, y, &@click_analysis_action) if @click_analysis_action.is_a?(Proc)
-                end
-                break
-              end
-            end
-          else
-            Universe.allow_tool_operations=true
-          end
-
-        }
-        @click_analysis_active = true
-      end
-
-    end
-
-    def de_activate_click_analysis
-      # alert 'we need to find how many  tools are still active'
-      @click_analysis = nil
-      @click_analysis_active = false
-    end
-
-    def start_click_analysis
-      @click_analysis_active = false
-      JS.global[:document].addEventListener('mouseup') do |native_event|
-        Atome.instance_exec(native_event, &@click_analysis) if @click_analysis.is_a?(Proc)
-      end
-    end
-
-  end
-
-  def build_tool(params, &bloc)
-    label = params[:name]
-    name = "#{params[:name]}_tool"
-    index = params[:index]
-    orientation = params[:orientation]
-    orientation_wanted = :sn
-    color({ id: :active_tool_col, alpha: 1, red: 1, green: 1, blue: 1 })
-    color({ id: :inactive_tool_col, alpha: 0.6 })
-    tool_content = Atome.instance_exec(&bloc) if bloc.is_a?(Proc)
-    grab(:intuition).storage[:tool_open] ||= []
-    grab(:intuition).storage[:tool_open] << name
-    size = grab(:toolbox_style).data[:size]
-    smooth = grab(:toolbox_style).data[:smooth]
-    case orientation_wanted
-    when :sn
-      top = :auto
-      bottom = index * (size + 3)
-      left = 0
-      right = :auto
-    when :ns
-    when :ew
-    when :we
-    else
-      #
-    end
-
-    # tool creation
-    tool = grab(:intuition).box({ id: name,
-                                  tag: { system: true },
-                                  # orientation: orientation_wanted,
-                                  top: top,
-                                  bottom: bottom,
-                                  left: left,
-                                  right: right,
-                                  width: size,
-                                  height: size,
-                                  smooth: smooth,
-                                  apply: [:tool_inactive_color, :tool_box_border, :tool_shade],
-                                  state: :closed,
-                                  # storage: { taxonomy: Intuition.impulse },
-                                })
-    tool.vector({ tag: { system: true }, left: 9, top: :auto, bottom: 9, width: 18, height: 18, id: "#{name}_icon" })
-    tool.text({ tag: { system: true }, data: label, component: { size: 9 }, color: :grey, id: "#{name}_label" })
-    tool.touch(true) do |ev|
-      # we add all specific tool actions to @tools_actions_to_exec hash
-
-      Atome.add_tool_actions(name, tool_content)
-      # we set allow_tool_operations to false to ignore tool operation when clicking on a tool
-      Universe.allow_tool_operations=false
-      # we create the creation_layer if not already exist
-
-      tick(name)
-      # active code exec
-      if tick[name] == 1 # first click
-        # we set edit mode to true (this allow to prevent user atome to respond from click)
-        Universe.edit_mode = true
-        # activate tool analysis test
-        Atome.activate_click_analysis
-
-        # check_me_first = lambda { |atome_id_found, x, y|
-        #   puts "first user atome ==> #{grab(atome_id_found).id}, x: #{x}, y: #{y}"
-        # }
-        # Atome.instance_variable_set('@click_analysis_action', check_me_first)
-        # init the tool
-        tool.data = []
-        # generic behavior
-        tool.apply(:active_tool_col)
-        # activation code
-        tool_content[:active].each do |code_exec|
-          tool.instance_exec(&code_exec)
-        end if tool_content && tool_content[:active]
-        if tool_content && tool_content[:alteration]
-          # here we treat any selected items on tool activation
-          tool_content[:alteration].each do |action|
-            Atome.selection.each do |atome_id_to_treat|
-              atome_to_treat=grab(atome_id_to_treat)
-              pre_proc = action[:pre]
-              tool.instance_exec(atome_to_treat,nil, &pre_proc) if pre_proc.is_a? Proc
-              particle_f = action[:particle]
-              value_f = action[:value]
-              atome_to_treat.send(particle_f, value_f)
-              post_proc = action[:post]
-              tool.instance_exec(atome_to_treat,nil, &post_proc) if post_proc.is_a? Proc
-            end
-          end
-        end
-
-      else
-        # when closing delete tools action from tool_actions_to_exec
-        Atome.tool_actions_to_exec.delete(name)
-        # we check if all tools are inactive if so we set edit_mode to false
-        if Atome.tool_actions_to_exec.length == 0
-          # puts "Atome.tool_actions_to_exec.length = 0"
-          Atome.de_activate_click_analysis
-          Universe.edit_mode = false
-        end
-
-        # inactivation code
-        tool_content[:inactive].each do |code_exec|
-          tool.instance_exec(tool.data, &code_exec)
-        end if tool_content && tool_content[:inactive]
-
-        # generic behavior
-        # we remove touch and resize binding on newly created atomes
-        tool.apply(:inactive_tool_col)
-        tool.data.each do |new_atome|
-          new_atome.drag(false)
-          new_atome.resize(:remove)
-        end
-        tick[name] = 0
-      end
-    end
-  end
-end
-
-module Intuition
-  class << self
-    @toolbox = { impulse: [:capture_tool, :communication_tool, :creation_tool, :view_tool, :time_tool, :find_tool, :home_tool],
-                 capture_tool: [:microphone_tool, :camera_tool,]
-    }
-
-    def intuition_int8
-      # tool taxonomy and list
-      {
-        capture: { int8: { french: :enregistrement, english: :record, german: :datensatz } },
-        communication: { french: :communication, english: :communication, german: :communication },
-        tool: { french: :outils, english: :tools, german: :werkzeuge },
-        view: { french: :vue, english: :view, german: :aussicht },
-        time: { french: :horloge, english: :clock, german: :Uhr },
-        find: { french: :trouve, english: :find, german: :finden },
-        home: { french: :accueil, english: :home, german: :zuhause },
-        code: { french: :code, english: :code, german: :code },
-        impulse: { french: :impulse, english: :impulse, german: :impulse },
-      }
-    end
-
-    def impulse
-
-      # initialise touchdown analysis
-      # Atome.start_click_analysis
-
-      # tool start point
-      # [:capture_tool, :communication, :tool, :view, :time, :find, :home]
-    end
-  end
-
-end
-
-##########################################################
-# new({ tool: :impulse }) do |params|
-#
-#   creation_code = lambda { |event|
-#     puts :box_creation
-#   }
-#
-#   active_code = lambda { |event|
-#     puts :start
-#     apply([:tool_active_color])
-#     storage[:taxonomy].each_with_index do |tool, index|
-#
-#       # Atome.display_tool("tool_#{tool}", index + 1, :ns)
+# # frozen_string_literal: true
+#
+# # m = table({ renderers: [:html], attach: :view, id: :my_test_box, type: :table, apply: [:shape_color],
+# #             left: 333, top: 0, width: 900, smooth: 15, height: 900, overflow: :scroll, option: { header: false },
+# #             component: {
+# #               # border: { thickness: 5, color: :blue, pattern: :dotted },
+# #               # overflow: :auto,
+# #               # color: "red",
+# #               shadow: {
+# #                 id: :s4,
+# #                 left: 20, top: 0, blur: 9,
+# #                 option: :natural,
+# #                 red: 0, green: 0, blue: 0, alpha: 1
+# #               },
+# #               height: 5,
+# #               width: 12,
+# #               component: { size: 12, color: :black }
+# #             },
+# #             # data: [
+# #             #   { titi: :toto },
+# #             #   { dfgdf: 1, name: 'Alice', age: 30, no: 'oko', t: 123, r: 654 },
+# #             #   { id: 2, name: 'Bob', age: 22 },
+# #             #   { dfg: 4, name: 'Vincent', age: 33, no: grab(:my_circle) },
+# #             #   { dfgd: 3, name: 'Roger', age: 18, no: image(:red_planet), now: :nothing }
+# #             #
+# #             # ]
+# #           })
+# b=box({top: 120})
+# box({top: 190, id: :the_box})
+#
+# b.touch(true) do
+#   a=JS.eval("return performance.now()")
+#   z=Time.now
+#   circle
+#   columns = []
+#
+#   96.times do
+#     line = {}
+#     128.times do |index|
+#       line[:"vel#{index}"] = nil
 #     end
-#     state(:open)
-#   }
-#
-#   inactive_code = lambda { |param|
-#     puts :stop
-#     # impulse.storage[:taxonomy].each do |tool|
-#     #   grab("tool_#{tool}").delete(true)
+#     columns << line
+#   end
+#   columns.each_with_index do |a, index|
+#     b= box({left: index*30, width: 12})
+#     # b.touch(true) do
+#     #   alert b.id
 #     # end
-#     # impulse.apply([:tool_inactive_color])
-#     # impulse.state(:closed)
-#   }
-#
-#   {
-#     active: [active_code],
-#     inactive: [inactive_code],
-#     creation: [creation_code],
-#     int8: { french: :impulse, english: :impulse, german: :impulse }
-#   }
-# end
-
-# toolbox creation
-# Atome.display_tool(:impulse, 0, :ns)
-# grab(:impulse).touch(true) do
-#   impulse = grab(:impulse)
-#   if impulse.state == :closed
-#     impulse.apply([:tool_active_color])
-#     impulse.storage[:taxonomy].each_with_index do |tool, index|
-#
-#       Atome.display_tool("tool_#{tool}", index + 1, :ns)
-#     end
-#     impulse.state(:open)
-#   else
-#     impulse.storage[:taxonomy].each do |tool|
-#       grab("tool_#{tool}").delete(true)
-#     end
-#     impulse.apply([:tool_inactive_color])
-#     impulse.state(:closed)
 #   end
-# end
-
-# ##############################################################################################
-
-new({ tool: :shape }) do |params|
-
-  active_code = lambda {
-    puts :creation_tool_code_activated
-    # puts "activation code here"
-  }
-
-  inactive_code = lambda { |atomes_treated|
-    puts :creation_tool_code_inactivated
-    # atomes_treated.each do |new_atome|
-    #   if new_atome.selected
-    #     new_atome.left(new_atome.left + 33)
-    #     new_atome.color({ red: rand, green: rand, blue: rand })
-    #   end
-    # end
-  }
-  pre_crea_code = lambda { |atome_touched, event|
-    puts "pre_creation_code : atome_touched : #{atome_touched} event : #{event} "
-    # Atome.selection.each do |atome_to_treat|
-    #   grab(atome_to_treat).color(:red)
-    #   grab(atome_to_treat).rotate(21)
-    #   puts "pre"
-    # end
-  }
-
-  post_crea_code = lambda { |atome_touched, new_atome, event|
-    puts "post_creation_code,atome_touched: #{atome_touched}, new_atome :#{new_atome}, event : #{event}"
-
-    # new_atome.color(:blue)
-    # puts "post"
-  }
-
-  creation_code = [{ type: :box, particles: { width: 66, height: 66 }, pre: pre_crea_code },
-                   { type: :circle, particles: { width: 66, height: 66 }, post: post_crea_code }
-  ]
-  pre_code = lambda { |atome_touched, event|
-    # grab(atome_touched).height(99)
-    puts 'alteration pre treatment'
-  }
-
-  post_code = lambda { |atome_touched, event|
-
-    atome_touched.height(199)
-    # new_atome.height(199) if  new_atome
-    # grab(new_atome).width(99)
-    puts 'alteration post treatment'
-
-  }
-
-  alterations = [{ particle: :blur, value: 3, pre: pre_code, post: post_code }]
-
-  { creation: creation_code, alteration: alterations,
-    active: [active_code],
-    inactive: [inactive_code],
-    int8: { french: :formes, english: :shape, german: :jesaispas } }
-
-end
-
-### tool2 test
-
-new({ tool: :color }) do |params|
-
-
-  active_code = lambda {
-    # grab(:intuition).data[:color] = :red
-    puts :alteration_tool_code_activated
-  }
-
-  inactive_code = lambda { |param|
-    puts :alteration_tool_code_inactivated
-  }
-  pre_code= lambda { |atome_touched, event|
-    puts "post_creation_code,atome_touched: #{atome_touched}, event : #{event}"
-
-    # new_atome.color(:blue)
-    # puts "post"
-  }
-  post_code= lambda { |atome_touched, event|
-    puts "post_creation_code,atome_touched: #{atome_touched}, event : #{event}"
-
-    # new_atome.color(:blue)
-    # puts "post"
-  }
-  alterations = [{ particle: :width, value: 22 }, { particle: :color, value: :red,  pre: pre_code,
-                                                    post: post_code, }, { particle: :rotate, value: 33 }]
-  {
-    active: [active_code],
-    inactive: [inactive_code],
-    alteration: alterations,
-
-    int8: { french: :couleur, english: :color, german: :colorad } }
-
-end
-
-# new({ tool: :color }) do |params|
-#
-#   { alteration: [{ particle: :blur, value: 22 }] }
-#
-# end
-# verif below
-# wait 1 do
-
-  Atome.init_intuition
-# end
-
-# ##############################################################################################
+#   z2=Time.now
+#   x=JS.eval("return performance.now();")
+#   alert "#{x.to_f-a.to_f} : #{(z2-z)*1000}"
 #
-
-b = box({ left: 123, top: 66, selected: false, id: :the_box })
-b.touch(:down) do
-  puts '"im touched"'
-end
-circle({ left: 123, top: 120, selected: true, id: :the_circle, drag: true })
-
-# def id_found_under_touch(obj_found)
-#   alert obj_found
 # end
-# aa=<<STR
-# document.addEventListener('click', function(event) {
-#     var x = event.clientX;
-#     var y = event.clientY;
-#     var elementUnderCursor = document.elementFromPoint(x, y).id;
-# Opal.Object.$id_found_under_touch(elementUnderCursor);
-# });
-# STR
 #
-#  JS.eval(aa)
-
-# ###################### marche
-class Atome
-
-  def set_action_on_touch(&action)
-    @touch_action = action
-
-  end
-
-  # def set_atome_on_touch
-  #   document = JS.global[:document]
-  #   document.addEventListener("click") do |native_event|
-  #     event = Native(native_event)
-  #     x = event[:clientX]
-  #     y = event[:clientY]
-  #     element = document.elementFromPoint(x, y)
-  #     element_id = element[:id]
-  #     puts "test if element is a system element  else select it "
-  #     @touch_action.call(element_id) if @touch_action.is_a? Proc
-  #   end
-  # end
-
-  # def set_atome_on_touch
-  #   document = JS.global[:document]
-  #   document.addEventListener("click") do |native_event|
-  #     event = Native(native_event)
-  #     x = event[:clientX]
-  #     y = event[:clientY]
-  #     element = document.elementFromPoint(x, y)
-  #
-  #     # Boucle pour remonter la hiérarchie des éléments
-  #     while element && element != document
-  #       # Vérifie si l'élément a l'ID 'view'
-  #       if element[:id].to_s == 'view'
-  #         element_id = element[:id]
-  #               @touch_action.call(element_id) if @touch_action.is_a? Proc
-  #
-  #         # alert "Clic sur un descendant de 'view'"
-  #         break
-  #       end
-  #       # Passe au parent de l'élément actuel
-  #       # element = element.JS[:parentNode]
-  #       break
-  #     end
-  #   end
-  # end
-
-  def remove_get_atome_on_touch
-    @touch_action = nil
-  end
-
-end
-
-###### verif
-# A.set_action_on_touch do |at_id|
-#   puts "==> #{at_id}"
-# end
-# A.set_atome_on_touch
 #
+# # m.data(columns)
+# # # tests
+# # m.color(:orange)
+# # m.border({ thickness: 5, color: :blue, pattern: :dotted })
+# #
+# #   m.get({ cell: [1, 2]}).class
+# # wait 2 do
+# #   m.insert({ cell: [2, 2], content: 999 })
+# #   m.insert({ row: 1 })
+# #   wait 1 do
+# #     m.remove({ row: 2 })
+# #   end
+# #   wait 2 do
+# #     m.remove({ column: 1 })
+# #   end
+# #   wait 3 do
+# #     m.insert({ column: 3 })
+# #   end
+# #
+# #   wait 4 do
+# #     m.sort({ column: 1, method: :alphabetic })
+# #     puts 1
+# #     wait 1 do
+# #       puts 2
+# #       m.sort({ column: 2, method: :numeric })
+# #       wait 1 do
+# #         puts 3
+# #         m.sort({ column: 3, method: :numeric })
+# #         wait 1 do
+# #           puts 4
+# #           m.sort({ column: 1, method: :numeric })
+# #         end
+# #       end
+# #     end
+# #   end
+# #
+# # end
+# #
+# # #  cell.fusion() # to be implemented later
+#
+#
+# # b=box({width: 1200, height: 900, color: {alpha: 0},top: -50})
+# # grab(:black_matter).image({id: :kb,path: 'medias/images/utils/keyboard.svg', width: 66, left: 55})
+# # # grab(:black_matter).image({id: :planet,path: 'medias/images/red_planet.png', width: 66,height: 66,  left: 555, top: 180})
+# # b.fill([atome:  :kb, repeat: {x: 8, y: 1}])
+# # b.drag(true)
+# #
+# #
+# # b2=box({width: 1200, height: 298,  top: -100})
+# # grab(:black_matter).image({id: :notes,path: 'medias/images/utils/notes.svg', width: 166, left: 55})
+# # # grab(:black_matter).image({id: :planet,path: 'medias/images/red_planet.png', width: 66,height: 66,  left: 555, top: 180})
+# # b2.fill([atome:  :notes, repeat: {x: 8, y: 5}])
+# # b2.drag(true)
+#
+#
+# JS.eval("
+# // Fonction pour créer les divs
+# function createDivs() {
+#   // Démarrer le chronomètre
+#   const startTime = performance.now();
+#
+#   const view = document.getElementById('view');
+#   //view.innerHTML = '';  // Nettoyer le contenu précédent de 'view' si nécessaire
+#
+#   // Boucle pour créer 98 divs sur l'axe X
+#   for (let i = 0; i < 98; i++) {
+#     const xDiv = document.createElement('div');
+#     xDiv.style.display = 'flex';
+#     xDiv.style.flexDirection = 'column';
+#     xDiv.style.margin = '2px';  // Marge entre les divs de l'axe X
+#
+#     // Boucle pour créer 128 divs sur l'axe Y
+#     for (let j = 0; j < 128; j++) {
+#       const yDiv = document.createElement('div');
+#       yDiv.style.width = '10px';  // Largeur de chaque div sur l'axe Y
+#       yDiv.style.height = '10px'; // Hauteur de chaque div sur l'axe Y
+#       yDiv.style.border = '1px solid black';  // Bordure pour rendre les divs visibles
+#       yDiv.style.boxSizing = 'border-box';    // Inclure la bordure dans les dimensions
+#       xDiv.appendChild(yDiv);
+#     }
+#
+#     view.appendChild(xDiv);
+#   }
 #
-# wait 2 do
-#   A.remove_get_atome_on_touch
-#   wait 3 do
-#     puts 'ready again !!'
-#     A.set_action_on_touch do |at_id|
-#       puts "******> #{at_id}"
-#     end
-#   end
-# end
-
-###### good algo
-# class Atome
-#   class << self
+#   // Arrêter le chronomètre
+#   const endTime = performance.now();
+#   const timeTaken = endTime - startTime;
 #
+#   // Afficher le temps écoulé en console
+#  alert(`Temps écoulé pour créer les divs : ${timeTaken.toFixed(2)} ms`);
+# }
 #
-#   end
+# // Ajouter un écouteur d'événements au div 'the_box'
+# document.getElementById('the_box').addEventListener('click', createDivs);
+# ``
 #
-# end
+# ")
 
-# check_me_first = lambda { |atome_id_found|
-#   puts "first user atome ==> #{grab(atome_id_found).id}"
-# }
-# Atome.instance_variable_set('@click_analysis_action', check_me_first)
-# alert grab(:intuition).instance_variable_get('@click_analysis_action')
-
-# wait 3 do
-#   check_me = lambda { |atome_id_found|
-#     puts "Cool cool cool, for :#{atome_id_found}"
-#   }
-#   Atome.instance_variable_set('@click_analysis_action', check_me)
-#   # wait 2 do
-#   #   Atome.de_activate_click_analysis
-#   #   alert :game_over
-#   # end
-# end
-
-# array1 = [1, 2, 3]
-# array2 = nil
-# array1.concat(array2) if array2
-#
-# alert array1
-bb = box()
+new({particle: :merge})
+a=box
+c=box
+d=a.merge(c)