initial commit

README.md

@@ -1,2 +1,8 @@
-# grafitti
+# grafitti
-Grafitti api for Minetest
+
+
+Grafitti API for Minetest  
+
+Code licensed as GPLv3 (see file LICENSE)  
+
+Screenshot:  

api.lua

@@ -0,0 +1,260 @@
+
+grafitti = {
+    _palettes = {}
+}
+
+local g = grafitti
+local _palette = {
+    width = 8,
+    items = {}
+}
+
+local _placers = {}
+
+function get_part_pos(i, size)
+    local row = (math.floor((i-1) / size.x))
+    local col = i-1 - math.floor((i-1)/size.x)*size.x
+    return {row=row, col=col}
+end
+
+function get_relative_node_pos(part_pos, center)
+    return {x=part_pos.col-center.col, y=part_pos.row-center.row}
+end
+
+function is_main_node(node_pos)
+    return node_pos.x == 0 and node_pos.y == 0
+end
+
+function get_node_name(name, node_pos)
+    if is_main_node(node_pos) then return name end
+    
+    local x = node_pos.x < 0 and "m"..math.abs(node_pos.x) or node_pos.x
+    local y = node_pos.y < 0 and "m"..math.abs(node_pos.y) or node_pos.y
+    return name .."_".. x .."_".. y
+end
+
+function get_image_name(name, part_pos, part_size)
+    return name .."^[sheet:".. part_size.x .."x".. part_size.y ..":".. part_pos.col ..",".. part_pos.row
+end
+
+function get_node_pos(pos, node_pos, param2)
+    if param2 == 0 then
+        return {x=pos.x+node_pos.x, y=pos.y, z=pos.z+node_pos.y}
+    end
+    
+    if param2 == 1 then
+        return {x=pos.x+node_pos.x, y=pos.y, z=pos.z-node_pos.y}
+    end
+        
+    if param2 == 2 then
+        return {x=pos.x, y=pos.y-node_pos.y, z=pos.z+node_pos.x}
+    end
+    
+    if param2 == 3 then
+        return {x=pos.x, y=pos.y-node_pos.y, z=pos.z-node_pos.x}
+    end
+    
+    if param2 == 4 then
+        return {x=pos.x+node_pos.x, y=pos.y-node_pos.y, z=pos.z}
+    end
+    
+    if param2 == 5 then
+        return {x=pos.x-node_pos.x, y=pos.y-node_pos.y, z=pos.z}
+    end
+end
+
+function init_def_values(def)
+    def = def or {}
+    def.size = def.size or {x=1, y=1}
+    def.center = def.center or {row=0, col=0}
+    def.pointable = def.pointable or false
+    return def
+end
+
+function g.register_grafitti(name, def)
+    def = init_def_values(def)
+    local parts_count = def.size and def.size.x*def.size.y or 1
+    
+    for i=1, parts_count, 1 do
+        local part_pos = get_part_pos(i, def.size)
+        local rel_node_pos = get_relative_node_pos(part_pos, def.center)
+        local node_name = get_node_name(name, rel_node_pos)
+        local image_name = parts_count == 1 and def.image 
+            or get_image_name(def.image, part_pos, def.size)
+        
+        minetest.register_node(node_name, {
+            inventory_image = def.image,
+            drawtype = "nodebox",
+            tiles = { image_name },
+            paramtype = "light",
+            paramtype2 = "wallmounted",
+            groups = {cracky=1, attached_node=1, not_in_creative_inventory=1, grafitti=1},
+            buildable_to = true,
+            walkable = false,
+            node_box = {
+                type = "wallmounted",
+                wall_top    = {-0.5, 0.49, -0.5, 0.5, 0.5, 0.5},
+                wall_bottom = {-0.5, -0.5, -0.5, 0.5, -0.49, 0.5},
+                wall_side   = {-0.5, -0.5, -0.5, -0.49, 0.5, 0.5},
+            },
+            pointable = def.pointable,
+            legacy_wallmounted = true,
+            drop = {},
+            on_construct = function(pos)
+                if parts_count == 1 or not is_main_node(rel_node_pos) then
+                    return
+                end
+                
+                local player_name = _placers[minetest.pos_to_string(pos)]
+                local wallmounted = minetest.get_node(pos).param2
+                
+                for j=1, parts_count, 1 do
+                    local _part_pos = get_part_pos(j, def.size)
+                    local _rel_node_pos = get_relative_node_pos(_part_pos, def.center)
+                    
+                    if not is_main_node(_rel_node_pos) then
+                        local node_pos = get_node_pos(pos, _rel_node_pos, wallmounted)
+                        local pos_under = vector.add(node_pos, minetest.wallmounted_to_dir(wallmounted))
+                        
+                        if not minetest.is_protected(node_pos, player_name)
+                        and not minetest.is_protected(pos_under, player_name)
+                        then
+                            local node_under = minetest.get_node(pos_under)
+                            local node_under_def = core.registered_items[node_under.name]
+                            
+                            if node_under_def and not node_under_def.buildable_to then
+                                local _node_name = get_node_name(name, _rel_node_pos)
+                                minetest.swap_node(vector.new(get_node_pos(pos, _rel_node_pos, wallmounted)), {
+                                    name = _node_name, 
+                                    param2 = wallmounted
+                                })
+                            end
+                        end
+                    end
+                end
+            end,
+            on_destruct = function(pos)
+                if parts_count == 1 or not is_main_node(rel_node_pos) then
+                    return
+                end
+                
+                _placers[minetest.pos_to_string(pos)] = nil
+            end
+        })
+    end
+
+    table.insert(_palette.items, { name=name, image=def.image })
+end
+
+function g.set_palette_width(width)
+    _palette.width = width
+end
+
+function g.palette_build(formspec_name)
+    local formspec_cols = _palette.width
+    local formspec_rows = math.ceil((#_palette.items+1)/formspec_cols)
+    local formspec = "size[".. formspec_cols ..",".. formspec_rows .."]"
+    
+    for i=1,#_palette.items,1 do
+        local name = _palette.items[i].name
+        local image = _palette.items[i].image
+        local row = math.ceil(i / formspec_cols)-1
+        local col = i-1 - math.floor((i-1) / formspec_cols)*formspec_cols
+        formspec = formspec .. "image_button_exit[".. col ..",".. row ..";1,1;".. image ..";".. name ..";]"
+    end
+    
+    _palette.items = {}
+    g._palettes[formspec_name] = formspec
+    
+    minetest.register_on_player_receive_fields(function(painter, formname, fields)
+        if formname ~= formspec_name then return end
+        
+        for item,v in pairs(fields) do
+            if core.registered_items[item] then
+                local itemstack = painter:get_wielded_item()
+                
+                if not core.registered_items[itemstack:get_name()].groups.brush then return end
+            
+                local meta = itemstack:get_meta()
+                meta:set_string("grafitti", item)
+                painter:set_wielded_item(itemstack)
+                return
+            end
+        end
+    end)
+end
+
+function show_palette(painter, formspec_name)
+    minetest.show_formspec(painter:get_player_name(), formspec_name, g._palettes[formspec_name])
+end
+
+function g.register_brush(brush_name, def)
+    minetest.register_tool(brush_name, {
+        description = def.description,
+        inventory_image = def.inventory_image,
+        wield_image = def.wield_image,
+        groups = { brush=1 },
+        
+        on_place = function(itemstack, placer, pointed_thing)
+            show_palette(placer, def.palette)
+        end,
+        
+        on_secondary_use = function(itemstack, user, pointed_thing)
+            show_palette(user, def.palette)
+        end,
+        
+        on_use = function(itemstack, user, pointed_thing)
+            local player_name = user:get_player_name()
+            local meta = itemstack:get_meta()
+            
+            if pointed_thing.type == "nothing" or meta:get_string("grafitti") == "" then
+                show_palette(user, def.palette)
+                return nil
+            end
+            
+            if pointed_thing.type ~= "node" then
+                return nil
+            end
+            
+            if minetest.is_protected(pointed_thing.above, player_name)
+            or minetest.is_protected(pointed_thing.under, player_name)
+            then
+                return nil
+            end
+            
+            local node_under = minetest.get_node(pointed_thing.under)
+            local node_under_def = core.registered_items[node_under.name]
+            if node_under_def and node_under_def.buildable_to then
+                if node_under_def.groups.grafitti then
+                    minetest.add_node(pointed_thing.under, {name = "air"})
+                end
+                return nil
+            end
+            
+            local node_above = minetest.get_node(pointed_thing.above)
+            local node_above_def = core.registered_items[node_above.name]
+            if node_above_def and not node_above_def.buildable_to then
+                return nil
+            end
+            
+            if node_above_def.groups.grafitti then
+                minetest.add_node(pointed_thing.above, {name = "air"})
+                return nil
+            end
+            
+            _placers[minetest.pos_to_string(pointed_thing.above)] = player_name
+            local dir = vector.direction(pointed_thing.above, pointed_thing.under)
+            local wallmounted = minetest.dir_to_wallmounted(dir)
+            minetest.add_node(pointed_thing.above, {name = meta:get_string("grafitti"), param2=wallmounted})
+            
+            return nil
+        end
+    })
+
+    if def.recipe then
+        minetest.register_craft({
+            output = brush_name,
+            recipe = def.recipe
+        })
+    end
+end

init.lua

@@ -0,0 +1,4 @@
+local MOD_NAME = core.get_current_modname()
+local MOD_PATH = core.get_modpath(MOD_NAME)
+
+dofile(MOD_PATH.."/api.lua")