|
|
grid_size = 8
|
|
|
grid_width = 5
|
|
|
grid_height = 5
|
|
|
grid_x = 14
|
|
|
grid_y = 34
|
|
|
|
|
|
center_glyph = 132
|
|
|
|
|
|
|
|
|
cursor = {
|
|
|
ing_slot=1,
|
|
|
ing_idx=1,
|
|
|
trait_slot=1,
|
|
|
x=0, y=0,
|
|
|
big_button=false,
|
|
|
}
|
|
|
partial_recipe = {
|
|
|
ingredients = {},
|
|
|
trait_listings = {},
|
|
|
final_selected_traits = {}
|
|
|
}
|
|
|
|
|
|
state = {
|
|
|
choosing_ingredient = true,
|
|
|
placing_trait = false,
|
|
|
finalizing = false,
|
|
|
|
|
|
filtered_ingredients={},
|
|
|
final_trait_options={},
|
|
|
}
|
|
|
|
|
|
function crafting_before()
|
|
|
center_glyph = rnd({132, 134, 164, 166})
|
|
|
|
|
|
cursor = {
|
|
|
ing_slot=1,
|
|
|
ing_idx=1,
|
|
|
trait_slot=1,
|
|
|
x=0, y=0,
|
|
|
big_button=false, -- are we selecting the big button?
|
|
|
}
|
|
|
|
|
|
partial_recipe = {
|
|
|
ingredients = {},
|
|
|
trait_listings = {},
|
|
|
final_selected_traits = {}
|
|
|
}
|
|
|
|
|
|
state = {
|
|
|
-- three state flags for which phase of synthesis we're in
|
|
|
choosing_ingredient = true, -- choosing an ingredient for one of the slots of the recipe.
|
|
|
placing_trait = false, -- placing a trait into the grid.
|
|
|
finalizing = false, -- selecting the final traits and clicking the create glyph
|
|
|
-- arrays in use
|
|
|
filtered_ingredients={}, -- the filtered list of ingredients we could use for the currently selected slot
|
|
|
final_trait_options={}, -- all the traits which were active at the end of the
|
|
|
}
|
|
|
update_filtered_ingredients()
|
|
|
end
|
|
|
|
|
|
function crafting_update()
|
|
|
if state.choosing_ingredient then
|
|
|
crafting_choice_update()
|
|
|
elseif state.placing_trait then
|
|
|
crafting_place_update()
|
|
|
elseif state.finalizing then
|
|
|
crafting_finalize_update()
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function crafting_choice_update()
|
|
|
local current_slot_requirement = current_recipe.ingredients[cursor.ing_slot]
|
|
|
|
|
|
if btnp(0) and cursor.ing_idx>1 then
|
|
|
sfx(3)
|
|
|
cursor.ing_idx -= 1
|
|
|
end
|
|
|
if btnp(1) and cursor.ing_idx<#state.filtered_ingredients then
|
|
|
sfx(3)
|
|
|
cursor.ing_idx += 1
|
|
|
end
|
|
|
|
|
|
local current_ingredient = state.filtered_ingredients[cursor.ing_idx]
|
|
|
|
|
|
if btnp(4) and current_ingredient ~= nil then
|
|
|
-- lock in this ingredient and move on to moving traits arund
|
|
|
add(partial_recipe.ingredients, current_ingredient)
|
|
|
|
|
|
if #(current_ingredient.traits) ~= 0 then
|
|
|
-- if there are traits on this ingredient, set them.
|
|
|
state.choosing_ingredient = false
|
|
|
state.placing_trait = true
|
|
|
|
|
|
cursor.trait_slot = 1
|
|
|
elseif #partial_recipe.ingredients < #current_recipe.ingredients then
|
|
|
-- if there are remaining ingredients to set, do that.
|
|
|
cursor.ing_idx = 1
|
|
|
cursor.ing_slot += 1
|
|
|
update_filtered_ingredients()
|
|
|
else
|
|
|
-- if there are no more ingredients to set, then move on to finalizing.
|
|
|
begin_finalize()
|
|
|
end
|
|
|
end
|
|
|
|
|
|
if btnp(5) then
|
|
|
local previous_index = cursor.ing_slot - 1
|
|
|
if #(partial_recipe.ingredients) == 0 then
|
|
|
-- if there's no ingredients set, we back out.
|
|
|
change_screen(screen_recipe_list)
|
|
|
|
|
|
--otherwise, there are ingreddients set, and cursor.ing_slot is greater than one.
|
|
|
elseif #(partial_recipe.ingredients[previous_index].traits) ~= 0 then
|
|
|
-- we're setting an ingredient.
|
|
|
-- the previous ingredient slot has an ingredient set with traits.
|
|
|
-- delete the last set trait and pick it up as our cursor.
|
|
|
local last_set_trait = deli(partial_recipe.trait_listings)
|
|
|
|
|
|
cursor.ing_slot -= 1
|
|
|
cursor.ing_idx = 1
|
|
|
cursor.trait_slot = last_set_trait.ingredient_trait_slot
|
|
|
cursor.x = last_set_trait.x
|
|
|
cursor.y = last_set_trait.y
|
|
|
|
|
|
state.choosing_ingredient = false
|
|
|
state.placing_trait = true
|
|
|
else
|
|
|
--we're setting an ingredient, but the previouus ingredient didn't have any traits.
|
|
|
deli(partial_recipe.ingredients)
|
|
|
cursor.ing_slot = cursor.ing_slot - 1
|
|
|
cursor.ing_idx = 1
|
|
|
update_filtered_ingredients()
|
|
|
end
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function update_filtered_ingredients()
|
|
|
local current_slot_requirement = current_recipe.ingredients[cursor.ing_slot]
|
|
|
state.filtered_ingredients = filter_list(
|
|
|
inventory,
|
|
|
function(ing)
|
|
|
if contains(partial_recipe.ingredients, ing) then return false end
|
|
|
if contains(ing.tags, current_recipe.ingredients[cursor.ing_slot]) then return true end
|
|
|
return current_slot_requirement == ing.title
|
|
|
end)
|
|
|
end
|
|
|
|
|
|
function crafting_place_update()
|
|
|
local current_ingredient = partial_recipe.ingredients[cursor.ing_slot]
|
|
|
local current_trait_name = current_ingredient.traits[cursor.trait_slot]
|
|
|
local current_trait = library.traits[current_trait_name]
|
|
|
|
|
|
local width = current_trait[4]
|
|
|
local height = current_trait[5]
|
|
|
|
|
|
if btnp(0) and cursor.x>0 then cursor.x -= 1 end
|
|
|
if btnp(1) and cursor.x+width < grid_width then cursor.x += 1 end
|
|
|
if btnp(2) and cursor.y>0 then cursor.y -= 1 end
|
|
|
if btnp(3) and cursor.y+height < grid_height then cursor.y += 1 end
|
|
|
|
|
|
if btnp(4) then
|
|
|
-- make a new trait listing
|
|
|
local new_trait_listing = {
|
|
|
ingredient_i_belong_to=cursor.ing_slot, -- index of the ingredient this strait belongs to
|
|
|
ingredient_trait_slot=cursor.trait_slot, -- which trait slot we came from
|
|
|
x=cursor.x, y=cursor.y, --offset of the piece in the grid
|
|
|
trait = current_trait, -- the trait in question
|
|
|
active = true, -- whether the trait is active
|
|
|
}
|
|
|
|
|
|
-- turn off all overlapped traits
|
|
|
for idx, trait_listing in ipairs(partial_recipe.trait_listings) do
|
|
|
if overlaps(trait_listing, new_trait_listing) then
|
|
|
trait_listing.active = false
|
|
|
end
|
|
|
end
|
|
|
|
|
|
-- add it to the record!~
|
|
|
add(partial_recipe.trait_listings, new_trait_listing)
|
|
|
|
|
|
-- move on to the next step
|
|
|
if cursor.trait_slot < #current_ingredient.traits then
|
|
|
-- if there's more traits to set, then we should keep setting traits!
|
|
|
cursor.trait_slot += 1
|
|
|
elseif cursor.ing_slot < #current_recipe.ingredients then
|
|
|
-- if there's more ingredients to set, then we move on to setting ingredients.
|
|
|
state.choosing_ingredient = true
|
|
|
state.placing_trait = false
|
|
|
|
|
|
cursor.trait_slot = 1
|
|
|
cursor.ing_slot += 1
|
|
|
cursor.ing_idx = 1
|
|
|
update_filtered_ingredients()
|
|
|
else
|
|
|
-- if there's no more ingredients to set, then we move on to finalizing.
|
|
|
begin_finalize()
|
|
|
end
|
|
|
end
|
|
|
|
|
|
if btnp(5) then
|
|
|
-- we are placing traits.
|
|
|
-- that means that cursor.ing_slot refers to an ingredient which is set
|
|
|
-- and cursor.trait_slot refers to 1 or 2, and one which isn't set.
|
|
|
-- if curssor.trait_slot is 2, then we should delete the last set trait.
|
|
|
if cursor.trait_slot == 1 then
|
|
|
state.choosing_ingredient = true
|
|
|
state.placing_trait = false
|
|
|
|
|
|
deli(partial_recipe.ingredients)
|
|
|
update_filtered_ingredients()
|
|
|
else
|
|
|
-- if we were placing the second trait, then we should go to placing the first trait,
|
|
|
-- which we also need to remoove from the trait listings.
|
|
|
cursor.trait_slot -= 1
|
|
|
local last = deli(partial_recipe.trait_listings)
|
|
|
cursor.x = last.x
|
|
|
cursor.y = last.y
|
|
|
end
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function begin_finalize()
|
|
|
sfx(2)
|
|
|
|
|
|
state.final_trait_options = filter_list(partial_recipe.trait_listings, function(x) return x.active end)
|
|
|
|
|
|
state.choosing_ingredient = false
|
|
|
state.placing_trait = false
|
|
|
state.finalizing = true
|
|
|
|
|
|
cursor.x = 0
|
|
|
cursor.y = 0
|
|
|
end
|
|
|
|
|
|
function crafting_finalize_update()
|
|
|
if #state.final_trait_options < 3 then cursor.big_button = true end
|
|
|
|
|
|
local newx = cursor.x
|
|
|
local newy = cursor.y
|
|
|
if btnp(0) then newx -= 1 end
|
|
|
if btnp(1) then newx += 1 end
|
|
|
if btnp(2) then newy -= 1 end
|
|
|
if btnp(3) then newy += 1 end
|
|
|
|
|
|
if not cursor.big_button
|
|
|
and (state.final_trait_options[2*newy + newx + 1] ~= nil)
|
|
|
and newx <= 1
|
|
|
and newx >= 0 then
|
|
|
cursor.x, cursor.y = newx, newy
|
|
|
elseif btnp(3) and not (btnp(0) or btnp(1) or btnp(2)) then
|
|
|
-- if the next selected thing was out of bounds but we pressed down, then we're highlighting the big button
|
|
|
cursor.big_button = true
|
|
|
end
|
|
|
local i = 2*cursor.y + cursor.x + 1
|
|
|
|
|
|
if btnp(4) and not cursor.big_button then
|
|
|
if contains(partial_recipe.final_selected_traits, i) then
|
|
|
del(partial_recipe.final_selected_traits, i)
|
|
|
elseif #partial_recipe.final_selected_traits < 2 then
|
|
|
add(partial_recipe.final_selected_traits, i)
|
|
|
end
|
|
|
end
|
|
|
|
|
|
if btnp(2) and cursor.big_button and #state.final_trait_options > 2 then
|
|
|
-- if we're on the big button, and there's enough trait options, then if we press up,
|
|
|
-- it should unsselect the big button.
|
|
|
cursor.big_button = false
|
|
|
end
|
|
|
|
|
|
if btnp(4) and cursor.big_button then
|
|
|
-- if you pressed o and had the big button selected, then do the thing!
|
|
|
make_the_product()
|
|
|
cursor.big_button = false
|
|
|
end
|
|
|
|
|
|
if btnp(5) then
|
|
|
local last_ingredient = partial_recipe.ingredients[#partial_recipe.ingredients]
|
|
|
|
|
|
if #last_ingredient.traits == 0 then
|
|
|
state.finalizing = false
|
|
|
state.choosing_ingredient = true
|
|
|
|
|
|
cursor.ing_idx = 1
|
|
|
|
|
|
deli(partial_recipe.ingredients)
|
|
|
else
|
|
|
local trait_listing = deli(partial_recipe.trait_listings)
|
|
|
|
|
|
state.finalizing = false
|
|
|
state.placing_trait = true
|
|
|
|
|
|
cursor.trait_slot = trait_listing.ingredient_trait_slot
|
|
|
cursor.x = trait_listing.x
|
|
|
cursor.y = trait_listing.y
|
|
|
end
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function make_the_product()
|
|
|
local product = make_item(library.item_blueprints[current_recipe.result])
|
|
|
product.quality = quality()
|
|
|
|
|
|
for ingredient in all(partial_recipe.ingredients) do
|
|
|
-- remove all the ingredientss that we used
|
|
|
del(inventory, ingredient)
|
|
|
end
|
|
|
|
|
|
product.traits = {}
|
|
|
|
|
|
if #state.final_trait_options < 3 then
|
|
|
for trait_listing in all(state.final_trait_options) do
|
|
|
add(product.traits, trait_listing.trait[1])
|
|
|
end
|
|
|
else
|
|
|
for idx in all(partial_recipe.final_selected_traits) do
|
|
|
add(product.traits, state.final_trait_options[idx].trait[1])
|
|
|
end
|
|
|
end
|
|
|
|
|
|
add(inventory, product)
|
|
|
sfx(5)
|
|
|
change_screen(screen_recipe_list)
|
|
|
end
|
|
|
|
|
|
function crafting_draw()
|
|
|
cls()
|
|
|
|
|
|
draw_background()
|
|
|
|
|
|
draw_paper(30,8,140,140)
|
|
|
draw_recipe_on_paper(current_recipe, 30, 8)
|
|
|
draw_recipe_in_progress_on_paper(30, 8)
|
|
|
|
|
|
-- puzzle grid including pieces
|
|
|
draw_grid()
|
|
|
|
|
|
if state.finalizing then
|
|
|
draw_finalizing_sheet()
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function draw_grid()
|
|
|
map(0,0, grid_x,grid_y, grid_width+1,grid_height+1)
|
|
|
for t in all(partial_recipe.trait_listings) do
|
|
|
if t.active then
|
|
|
map(t.trait[2], t.trait[3],
|
|
|
(t.x*grid_size)+grid_x, (t.y*grid_size)+grid_y,
|
|
|
t.trait[4], t.trait[5])
|
|
|
end
|
|
|
end
|
|
|
|
|
|
if (state.placing_trait) then
|
|
|
local current_ingredient = partial_recipe.ingredients[cursor.ing_slot]
|
|
|
local current_trait_label = current_ingredient.traits[cursor.trait_slot]
|
|
|
local trait = library.traits[current_trait_label]
|
|
|
|
|
|
-- draw the currently selected trait into the grid
|
|
|
map(trait[2], trait[3],
|
|
|
(cursor.x*grid_size)+grid_x, (cursor.y*grid_size)+grid_y,
|
|
|
trait[4], trait[5])
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function draw_recipe_in_progress_on_paper(x, y)
|
|
|
-- selected ingredients
|
|
|
for i, ing in ipairs(partial_recipe.ingredients) do
|
|
|
draw_ingredient_listing(ing, x+40, y + 26*i)
|
|
|
end
|
|
|
color(blank_ingredient_outline_color)
|
|
|
|
|
|
for i=(cursor.ing_slot+1),#current_recipe.ingredients do
|
|
|
print(current_recipe.ingredients[i], x+46, y+2+26*i+9)
|
|
|
end
|
|
|
|
|
|
|
|
|
-- quality listing
|
|
|
color(base_text_color)
|
|
|
print("quality", x+2, y+12)
|
|
|
print_quality(quality(), x+44, y+18)
|
|
|
|
|
|
|
|
|
if state.choosing_ingredient and cursor.ing_slot < #current_recipe.ingredients + 1 then
|
|
|
-- draw a box around the ingredient we're choosing
|
|
|
yc = y + 26*cursor.ing_slot
|
|
|
xc = x+40
|
|
|
rect(xc, yc, xc+55, yc+26,10)
|
|
|
spr(6, xc-8, yc+10)
|
|
|
spr(7, xc+56, yc+10)
|
|
|
|
|
|
|
|
|
local current_ingredient = state.filtered_ingredients[cursor.ing_idx]
|
|
|
|
|
|
if current_ingredient == nil then
|
|
|
color(blank_ingredient_outline_color)
|
|
|
print(current_recipe.ingredients[cursor.ing_slot], x+46, y+2+26*cursor.ing_slot+9)
|
|
|
else
|
|
|
-- draw the ingredient listing for the selected ingredient
|
|
|
draw_ingredient_listing(current_ingredient, xc, yc)
|
|
|
end
|
|
|
elseif state.placing_trait then
|
|
|
-- draw a marker for the trait we're picking
|
|
|
yc = y + 26*cursor.ing_slot
|
|
|
yc = 3+yc+cursor.trait_slot*6
|
|
|
xc = x+38
|
|
|
spr(8, xc, yc)
|
|
|
end
|
|
|
|
|
|
for i, t in ipairs(filter_list(partial_recipe.trait_listings, function(trait) return trait.active end)) do
|
|
|
color(base_text_color)
|
|
|
print(t.trait[1], x+5, y+78 + 8*i)
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function draw_finalizing_sheet()
|
|
|
if #state.final_trait_options > 2 then
|
|
|
draw_paper(24, 10, 128-24-24, 128-10-10)
|
|
|
color(highlight_text_color)
|
|
|
print("pick two traits\nto keep!",32, 20)
|
|
|
|
|
|
for i, trait_listing in ipairs(state.final_trait_options) do
|
|
|
xi, yi = (i-1)%2, (i+i%2-2)/2
|
|
|
x, y = 64-32+xi*32, 34+yi*8
|
|
|
if contains(partial_recipe.final_selected_traits, i) then
|
|
|
rect(x-1, y-1, x+29, y+5, 10)
|
|
|
end
|
|
|
if not cursor.big_button and xi == cursor.x and yi == cursor.y then
|
|
|
rect(x-2, y-2, x+30, y+6, 0)
|
|
|
end
|
|
|
if contains(partial_recipe.final_selected_traits, i) then
|
|
|
color(highlight_text_color)
|
|
|
else
|
|
|
color(base_text_color)
|
|
|
end
|
|
|
print(trait_listing.trait[1], x, y )
|
|
|
end
|
|
|
|
|
|
--draw_paper(40, 76, 128-40-40, 12)
|
|
|
color(highlight_text_color)
|
|
|
if cursor.big_button then
|
|
|
pal(9,0)
|
|
|
else
|
|
|
palt(12, true)
|
|
|
end
|
|
|
spr(128, 64-16, 72, 4,4)
|
|
|
spr(center_glyph, 64-8, 80, 2, 2)
|
|
|
pal()
|
|
|
palt()
|
|
|
if cursor.big_button then
|
|
|
color(12)
|
|
|
else
|
|
|
color(highlight_text_color)
|
|
|
end
|
|
|
print("create!", 64-12, 108)
|
|
|
else
|
|
|
draw_paper(30, 30, 128-30-30, 128-30-30)
|
|
|
pal(9,0)
|
|
|
spr(128, 64-16, 60-16, 4,4)
|
|
|
spr(center_glyph, 64-8, 60-8, 2, 2)
|
|
|
pal()
|
|
|
palt()
|
|
|
if cursor.big_button then
|
|
|
color(12)
|
|
|
else
|
|
|
color(highlight_text_color)
|
|
|
end
|
|
|
print("create!", 64-12, 80)
|
|
|
end
|
|
|
end
|
|
|
|
|
|
function quality()
|
|
|
local quality_sum = 0
|
|
|
|
|
|
for ing in all(partial_recipe.ingredients) do
|
|
|
quality_sum += ing.quality
|
|
|
end
|
|
|
|
|
|
if #partial_recipe.ingredients > 1 then
|
|
|
quality_sum = flr(quality_sum/#partial_recipe.ingredients)
|
|
|
else
|
|
|
quality_sum = flr(quality_sum)
|
|
|
end
|
|
|
|
|
|
for trait in all(partial_recipe.traits) do
|
|
|
if trait.active then quality_sum += 5 end
|
|
|
end
|
|
|
|
|
|
return quality_sum
|
|
|
end
|
|
|
|
|
|
screen_crafting_raw = {before=crafting_before, draw=crafting_draw, update=crafting_update}
|
|
|
screen_crafting = screen_conversation({
|
|
|
{ph_p, [[when i craft, i pick which of each ingredient to use with left and right,]]},
|
|
|
{ph_p, [[and press 🅾️ to lock them in.]]},
|
|
|
{ph_p, [[some items have additional traits for their special properties.]]},
|
|
|
{ph_p, [[i set a puzzle piece into the grid for each trait on the object.]]},
|
|
|
{ph_p, [[every trait i put in the grid increases the overall quality.]]},
|
|
|
{ph_p, [[but if you overlap other traits' tiles, it'll remove the old ones!]]},
|
|
|
{ph_p, [[then at the end, you can pick two traits to transfer]]},
|
|
|
{ph_p, [[onto the final product.]]},
|
|
|
},
|
|
|
function()
|
|
|
screen_crafting = screen_crafting_raw
|
|
|
change_screen(screen_crafting)
|
|
|
end,
|
|
|
screen_crafting_raw)
|
|
|
|
