Hey
I need to make a modal choose dialog like the following one:
So basically you have a set of options, title and a return for the selected option. What would be a nice way to make this in a generic way?
I just need a little hint to kick-start the code
You could have a frame loop inside a function that handles the up/down and re-rending the screen and then the function itself could return the value chosen, although that will bloat your code vs just using a state engine like seen in almost all games. You make the menu a state and enter that state and in your main loop run the menu processing code each time until a choice is made, then switch states appropriately or handle the selection, etc.
Tada:
This might take a bit of getting your head around (mainly because of the progmem reading involved),
but adding new options is as simple as sticking new items in the array.
You might not want to go for a function-pointer system, you might just want to use an âitem idâ or something (particularly if this is just a âselect option, get itemâ system) but function pointers will facilitate doing more advanced things like healing the player or changing other player stats.
Youâll need to alter the drawing code to make it more like your example, and I havenât added a demo of adding A-button functionality (though I will if asked nicely) but the concept is there at least. You can sort of see what the idea is.
It can also be simplified by using memcpy_P, which Iâll update into the repo to do when Iâve got a minute.
I have now updated the repo to use memcpy_P, which works out to be slightly cheaper.
Wonderful! It makes complete sense how you designed it 
When I saw the question it was kind of spooky because I designed/implemented that system just yesterday.
Though my use case is slightly different, Iâm using it for a credits page.
Instead of a Menu and MenuOption Iâve got an array of Category with a category title and a list of peopleâs names.
If you decide to use it, let me know what your experience is like. (E.g. are there any downsides/issues/bugs or if you find other cool ways of using it.)
Hey @Pharap what is the point of using the struct here?:
struct Player
{
// fill with your player
};
using MenuAction = void (*)(Player *);
Also, I see obscure stuff in utilities.h 
Player is just a placeholder for whatever you want to pass to the action associated with each button.
Unless you meant
using MenuAction = void (*)(Player *);
in which case thatâs C++'s type-alias using (like typedef, but backwards (or rather the right way around - typdef is the backwards one)) of a function pointer. (You could also use a class with a virtual function if you prefered, but a function pointer is probably cheaper and easier.)
I just updated the repo.
Now MenuAction is using MenuAction = void (*)(Player &); instead, you you donât have to worry about pointers.
Iâve also added ApplyMenuAction and ApplyProgmemMenuAction and updated the .ino to demonstrate their use.
Basically you just fill in the Player with whatever data the player has and fill in the bodies of the functions GivePlayerTable, GivePlayerOrnament and GivePlayerLaptop.
Iâve only used function pointers to show that the system can give flexibility, depending on your menu system it might be cheaper to use something else (like just an item).
Iâm sure youâll be able to work it out from my changes, but if you have any other questions donât hesitate to ask. If you already know how your player, inventory system and items are going to be structured I can help you integrate the menu system if youâd like.
Theyâre not that obscure, theyâre just less well known techniques.
Explanation for AsFlashStringHelper:
Arduino provides a type called __FlashStringHelper to allow print systems to differentiate a pointer to a block of text from a pointer to a byte-sized integer (since technically they use the same types).
If you try to use:
// somewhere in global
const char text[] PROGMEM = "Hello World";
// somewhere in a function
arduboy.println(text);
The string gets garbled because itâs interpreted as something different.
However if you do:
// somewhere in global
const char text[] PROGMEM = "Hello World";
// somewhere in a function
arduboy.println(AsFlashStringHelper(text));
You get the correct result, because the text is converted to a const __FlashStringHelper * which the arduboy then correctly interprets as a string in progmem. The reason the F macro doesnât produce garbled strings is because it returns a const __FlashStringHelper *.
ArrayLength is a function template.
Templates are a very powerful C++ feature that aparently not many people here are particularly well acquainted with.
I canât really give a proper explanation without explaining templates in full, so Iâll give a very brief glossed-over explanation to give you an idea of how it works.
template< typename T, size_t N > constexpr size_t ArrayLength(T (&)[N])
{
return N;
}
The template<typename T, size_t N> part is the actual template part, and the T and N are called template arguments.
The T is a name that stands in for any type and the N is a name that stands in for any size_t value. In a sense theyâre a bit like actual function arguments in that they can be different values, but theyâre constant, exist only at compile time and can refer to type names.
The clever bit is (T (&)[N]). C++ has a thing called âtemplate deductionâ where the compiler will try to match up any of the values in the angle brackets based on the arguments given to the function. The argument (T (&)[N]) matches a reference to an array of any type and of any length, the T template argument matches the type and the N argument matches the length. The function itself returns the length and the constexpr makes almost certain that itâs calculated at compile time, so itâs no different to just manually sticking the array length in, except the compiler does it for you.
Thanks a lot for the detailed explanation! I am going to use this in my game 
Sometimes I wish to have a better IDE, it is really a mess in arduino to have the .h and .ino files, how they behave is quite weird sometimes
No problem, Iâm always willing to answer questions, explain things and generally help where I can.
Glad to hear that. Let me know if you have any trouble adapting it.
I tend to use notepad++ or visual studio and set the IDE to âuse external sourceâ. I have to switch window to compile, but itâs worth the better auto-complete and syntax highlighting.
I use Atom ⌠its quite nice as well.
Looks good⌠and gave me an idea (to prevent this thread going off on an interesting tangent):
I have just had a chance to look at this ⌠this is pretty cool and I love the fact that it uses progmem nearly exclusively. If I was to build an Arduventure II, I would use this!
Just a dumb question, how do I compare menus? for example if(EquipmentMenu == Something)
This menu thing would be great thing for an Arduino library, not just for arduboy but as a general stuff
It depends what your code is doing.
If youâve got a pointer to the menu, e.g. Menu * currentMenu = &EquipmentMenu; then you can just do pointer comparison if(currentMenu == &EquipmentMenu).
Otherwise itâll need a custom comparison operator to do memberwise comparison, which could get a bit tricky depending on which argument is in progmem and which isnât.
For the case where neither are in progmem:
bool operator==(const Menu & left, const Menu & right)
{
return (left.Title == right.Title) // Pointer comparison
&& (left.Options == right.Options) // Pointer comparison
&& (left.OptionsLength == right.OptionsLength);
}
Then itâd be a case of reading them out of progmem beforehand.
Otherwise, if both are in progmem:
bool progmemCompare(const Menu & left, const Menu & right)
{
return (pgm_read_word(&left.Title) == pgm_read_word(&right.Title)) // Pointer comparison
&& (pgm_read_word(&left.Options) == pgm_read_word(&right.Options)) // Pointer comparison
&& (pgm_read_byte(&left.OptionsLength) == pgm_read_byte(&right.OptionsLength));
}
Please note that I havenât actually tested either of these because this isnât something Iâve had to do myself yet, but Iâm 95% sure the first one works and 70% sure the second one works.
Thanks! I will test this afternoon. This is only because I want to call the âmodalâ menu when the current menu is not âemptyâ (so I would love to compare the current menu to an empty one)
If youâre looking for an âempty menuâ and youâre using pointers, you could always designate nullptr/NULL as the âempty menu pointerâ.
Otherwise if youâre passing around progmem pointers all the time then a pointer comparison will be the easiest because thereâs no progmem reading involved and the pointers are guaranteed.
If youâre loading the menus out of progmem and into objects, thatâs when the comparison starts getting tricky (and to be honest, thatâs probably worth delaying until the drawing and selection parts anyway).
If your strings are in an array then youâd just keep track of the menuâs chosen index and you could either check it against the raw pointers or have some defines:
#define EQUIPMENT 1
if (choice == EQUIPMENT) { ... }
Or do the same thing using an enum, etc.