void merge_invlet_test( player &dummy, inventory_location from )
{
// invlet to assign
constexpr char invlet_1 = '{';
constexpr char invlet_2 = '}';
// should merge from a place other than the inventory
REQUIRE( from != INVENTORY );
// cannot assign invlet to items on the ground
REQUIRE( from != GROUND );
for( int id = 0; id < INVLET_STATE_NUM * INVLET_STATE_NUM; ++id ) {
// how to assign invlet to the first item
invlet_state first_invlet_state = invlet_state( id % INVLET_STATE_NUM );
// how to assign invlet to the second item
invlet_state second_invlet_state = invlet_state( id / INVLET_STATE_NUM );
// what the invlet should be for the merged stack
invlet_state expected_merged_invlet_state = first_invlet_state != NONE ? first_invlet_state : second_invlet_state;
char expected_merged_invlet = first_invlet_state != NONE ? invlet_1 : second_invlet_state != NONE ? invlet_2 : 0;
// remove all items
dummy.inv.clear();
dummy.worn.clear();
dummy.remove_weapon();
g->m.i_clear( dummy.pos() );
// some stackable item
item tshirt( "tshirt" );
// add the item
add_item( dummy, tshirt, INVENTORY );
add_item( dummy, tshirt, from );
// assign the items with invlets
assign_invlet( dummy, item_at( dummy, 0, INVENTORY ), invlet_1, first_invlet_state );
assign_invlet( dummy, item_at( dummy, 0, from ), invlet_2, second_invlet_state );
// merge the second item into inventory
move_item( dummy, 0, from, INVENTORY );
item &merged_item = item_at( dummy, 0, INVENTORY );
invlet_state merged_invlet_state = check_invlet( dummy, merged_item, expected_merged_invlet );
char merged_invlet = merged_item.invlet;
std::stringstream ss;
ss << "1. add two stackable items to the inventory and " << location_desc( from ) << std::endl;
ss << "2. assign " << invlet_state_desc( first_invlet_state ) << " invlet " << invlet_1 << " to the item in the inventory " << std::endl;
ss << "3. assign " << invlet_state_desc( second_invlet_state ) << " invlet " << invlet_2 << " to the " << location_desc( from ) << std::endl;
ss << "4. " << move_action_desc( 0, from, INVENTORY ) << std::endl;
ss << "expect the stack in the inventory to have " << invlet_state_desc( expected_merged_invlet_state ) << " invlet " << expected_merged_invlet << std::endl;
ss << "the stack actually has " << invlet_state_desc( merged_invlet_state ) << " invlet " << merged_invlet << std::endl;
INFO( ss.str() );
REQUIRE( merged_item.typeId() == tshirt.typeId() );
CHECK( merged_invlet_state == expected_merged_invlet_state );
CHECK( merged_invlet == expected_merged_invlet );
}
}
void map_t::way_node_add(lpos_t pos) {
/* check if we are still hovering above the selected way */
map_item_t *item = item_at(pos);
if(item_is_selected_way(item)) {
/* convert mouse position to canvas (world) position */
const int insert_after = canvas->get_item_segment(item->item, pos);
if(insert_after >= 0) {
/* insert it into ways chain of nodes */
way_t *way = item->object.way;
/* create new node */
node_t* node = way->insert_node(appdata.project->osm, insert_after + 1, pos);
/* clear selection */
item_deselect();
/* draw the updated way */
draw(way);
/* and now draw the node */
draw(node);
/* put gui into idle state */
set_action(MAP_ACTION_IDLE);
/* and redo it */
select_way(way);
}
}
}
void stack_invlet_test( player &dummy, inventory_location from, inventory_location to )
{
// invlet to assign
constexpr char invlet = '|';
// duplication will most likely only happen if the stack is in the inventory
// and is subsequently wielded or worn
if( from != INVENTORY || ( to != WORN && to != WIELDED_OR_WORN ) ) {
FAIL( "unimplemented" );
}
// remove all items
dummy.inv.clear();
dummy.worn.clear();
dummy.remove_weapon();
g->m.i_clear( dummy.pos() );
// some stackable item that can be wielded and worn
item tshirt( "tshirt" );
// add two such items to the starting position
add_item( dummy, tshirt, from );
add_item( dummy, tshirt, from );
// assign the stack with invlet
assign_invlet( dummy, item_at( dummy, 0, from ), invlet, CACHED );
// wield or wear one of the items
move_item( dummy, 0, from, to );
std::stringstream ss;
ss << "1. add a stack of two same items to " << location_desc( from ) << std::endl;
ss << "2. assign the stack with an invlet" << std::endl;
ss << "3. " << move_action_desc( 0, from, to ) << std::endl;
ss << "expect the two items to have different invlets" << std::endl;
ss << "actually the two items have " <<
( item_at( dummy, 0, to ).invlet != item_at( dummy, 0, from ).invlet ? "different" : "the same" ) <<
" invlets" << std::endl;
INFO( ss.str() );
REQUIRE( item_at( dummy, 0, from ).typeId() == tshirt.typeId() );
REQUIRE( item_at( dummy, 0, to ).typeId() == tshirt.typeId() );
// the wielded/worn item should have different invlet from the remaining item
CHECK( item_at( dummy, 0, to ).invlet != item_at( dummy, 0, from ).invlet );
// clear invlets
assign_invlet( dummy, item_at( dummy, 0, from ), invlet, NONE );
assign_invlet( dummy, item_at( dummy, 0, to ), invlet, NONE );
}
std::string help_text_area::ref_at(const int x, const int y)
{
const int local_x = x - location().x;
const int local_y = y - location().y;
if (local_y < static_cast<int>(height()) && local_y > 0) {
const int cmp_y = local_y + get_position();
const std::list<item>::const_iterator it =
std::find_if(items_.begin(), items_.end(), item_at(local_x, cmp_y));
if (it != items_.end()) {
if ((*it).ref_to != "") {
return ((*it).ref_to);
}
}
}
return "";
}
void move_player( Actor& player )
{
// The direction the user wants to move, if any.
Vec inputDir = { 0, 0 };
// We need to know if we're standing on an item, but can't construct
// the object inside the switch, so do it now.
auto itemHere = item_at( player.pos );
int key = getch();
switch( key )
{
case 'l': case '6': case KEY_RIGHT: inputDir = Vec( 1, 0 ); break;
case 'h': case '4': case KEY_LEFT: inputDir = Vec( -1, 0 ); break;
case 'k': case '8': case KEY_UP: inputDir = Vec( 0, -1 ); break;
case 'j': case '2': case KEY_DOWN: inputDir = Vec( 0, 1 ); break;
case 'y': case '7': inputDir = Vec( -1, -1 ); break;
case 'u': case '9': inputDir = Vec( 1, -1 ); break;
case 'b': case '1': inputDir = Vec( -1, 1 ); break;
case 'n': case '3': inputDir = Vec( 1, 1 ); break;
case 'p': case 'g':
if( itemHere != items.end() )
{
player.inventory.push_back( itemHere->item );
items.erase( itemHere );
log( "Got %s!", player.inventory.back().c_str() );
}
else
log( "There's nothing here." );
break;
case 'C': if( ! combine(&player.inventory) )
log( "I can't combine them." );
break;
case 'c': log( "..." ); break;
case 'q': quit = true; break;
default: log( "Is that key supposed to do something?" ); break;
}
if( inputDir.x or inputDir.y )
if( not walk(player, inputDir) )
log( "Cannot move there." );
}
//
// Respond client with Owl's queue.
//
// Format:
// { queue : [
// { "id" : <link>, "artist" : "<artist>", "title" : "<title>", "duration" : int, "album" : "<album>" },
// { "id" : <link>, "artist" : "<artist>", "title" : "<title>", "duration" : int, "album" : "<album>" },
// { "id" : <link>, "artist" : "<artist>", "title" : "<title>", "duration" : int, "album" : "<album>" }]
//
static void respond_with_queue(struct evhttp_request *http_request, struct owl_queue *queue) {
TRACE("Responding with queue\n");
const int size = queue_size(queue);
struct evbuffer *content_buffer = evbuffer_new();
evbuffer_add_printf(content_buffer, "{ \"queue\" : [");
for(int i = 0; i < size; i++) {
const owl_track *track = item_at(queue, i);
evbuffer_add_printf(content_buffer, "%s", track->json);
if(i < (size -1))
evbuffer_add_printf(content_buffer, ",");
}
evbuffer_add_printf(content_buffer, "]}");
evhttp_add_header(evhttp_request_get_output_headers(http_request), "Content-type", "application/json; charset=UTF-8");
evhttp_send_reply(http_request, HTTP_OK, USER_AGENT, content_buffer);
}
void swap_invlet_test( player &dummy, inventory_location loc )
{
// invlet to assign
constexpr char invlet_1 = '{';
constexpr char invlet_2 = '}';
// cannot swap invlets of items on the ground
REQUIRE( loc != GROUND );
// remove all items
dummy.inv.clear();
dummy.worn.clear();
dummy.remove_weapon();
g->m.i_clear( dummy.pos() );
// two items of the same type that do not stack
item tshirt1( "tshirt" );
item tshirt2( "tshirt" );
tshirt2.mod_damage( -1 );
// add the items
add_item( dummy, tshirt1, loc );
add_item( dummy, tshirt2, loc );
// assign the items with invlets
assign_invlet( dummy, item_at( dummy, 0, loc ), invlet_1, CACHED );
assign_invlet( dummy, item_at( dummy, 1, loc ), invlet_2, CACHED );
// swap the invlets (invoking twice to make the invlet non-player-assigned)
dummy.reassign_item( item_at( dummy, 0, loc ), invlet_2 );
dummy.reassign_item( item_at( dummy, 0, loc ), invlet_2 );
// drop the items
move_item( dummy, 0, loc, GROUND );
move_item( dummy, 0, loc, GROUND );
// get them again
move_item( dummy, 0, GROUND, loc );
move_item( dummy, 0, GROUND, loc );
std::stringstream ss;
ss << "1. add two items of the same type to " << location_desc( loc ) <<
", and ensure them do not stack" << std::endl;
ss << "2. assign different invlets to the two items" << std::endl;
ss << "3. swap the invlets by assign one of the items with the invlet of the other item" <<
std::endl;
ss << "4. move the items to " << location_desc( GROUND ) << std::endl;
ss << "5. move the items to " << location_desc( loc ) << " again" << std::endl;
ss << "expect the items to keep their swapped invlets" << std::endl;
if( item_at( dummy, 0, loc ).invlet == invlet_2 && item_at( dummy, 1, loc ).invlet == invlet_1 ) {
ss << "the items actually keep their swapped invlets" << std::endl;
} else {
ss << "the items actually does not keep their swapped invlets" << std::endl;
}
INFO( ss.str() );
REQUIRE( item_at( dummy, 0, loc ).typeId() == tshirt1.typeId() );
REQUIRE( item_at( dummy, 1, loc ).typeId() == tshirt2.typeId() );
// invlets should not disappear and should still be swapped
CHECK( item_at( dummy, 0, loc ).invlet == invlet_2 );
CHECK( item_at( dummy, 1, loc ).invlet == invlet_1 );
CHECK( check_invlet( dummy, item_at( dummy, 0, loc ), invlet_2 ) == CACHED );
CHECK( check_invlet( dummy, item_at( dummy, 1, loc ), invlet_1 ) == CACHED );
// clear invlets
assign_invlet( dummy, item_at( dummy, 0, loc ), invlet_2, NONE );
assign_invlet( dummy, item_at( dummy, 1, loc ), invlet_1, NONE );
}
void invlet_test( player &dummy, inventory_location from, inventory_location to )
{
// invlet to assign
constexpr char invlet = '|';
// iterate through all permutations of test actions
for( int id = 0; id < INVLET_STATE_NUM * INVLET_STATE_NUM * TEST_ACTION_NUM; ++id ) {
// how to assign invlet to the first item
invlet_state first_invlet_state = invlet_state( id % INVLET_STATE_NUM );
// how to assign invlet to the second item
invlet_state second_invlet_state = invlet_state( id / INVLET_STATE_NUM % INVLET_STATE_NUM );
// the test steps
test_action action = test_action( id / INVLET_STATE_NUM / INVLET_STATE_NUM % TEST_ACTION_NUM );
// the final expected invlet state of the two items
invlet_state expected_first_invlet_state = second_invlet_state == NONE ? first_invlet_state : NONE;
invlet_state expected_second_invlet_state = second_invlet_state;
// remove all items
dummy.inv.clear();
dummy.worn.clear();
dummy.remove_weapon();
g->m.i_clear( dummy.pos() );
// some two items that can be wielded, worn, and picked up
item tshirt( "tshirt" );
item jeans( "jeans" );
// add the items to the starting position
add_item( dummy, tshirt, to );
add_item( dummy, jeans, to );
// assign invlet to the first item
assign_invlet( dummy, item_at( dummy, 0, to ), invlet, first_invlet_state );
// remove the first item
move_item( dummy, 0, to, from );
// assign invlet to the second item
assign_invlet( dummy, item_at( dummy, 0, to ), invlet, second_invlet_state );
item *final_first = nullptr, *final_second = nullptr;
switch( action ) {
case REMOVE_1ST_REMOVE_2ND_ADD_1ST_ADD_2ND:
move_item( dummy, 0, to, from );
move_item( dummy, 0, from, to );
move_item( dummy, 0, from, to );
final_first = &item_at( dummy, 0, to );
final_second = &item_at( dummy, 1, to );
break;
case REMOVE_1ST_REMOVE_2ND_ADD_2ND_ADD_1ST:
move_item( dummy, 0, to, from );
move_item( dummy, 1, from, to );
move_item( dummy, 0, from, to );
final_first = &item_at( dummy, 1, to );
final_second = &item_at( dummy, 0, to );
break;
case REMOVE_1ST_ADD_1ST:
move_item( dummy, 0, from, to );
final_first = &item_at( dummy, 1, to );
final_second = &item_at( dummy, 0, to );
break;
default:
FAIL( "unimplemented" );
break;
}
invlet_state final_first_invlet_state = check_invlet( dummy, *final_first, invlet ),
final_second_invlet_state = check_invlet( dummy, *final_second, invlet );
INFO( test_action_desc( action, from, to, first_invlet_state, second_invlet_state,
expected_first_invlet_state, expected_second_invlet_state, final_first_invlet_state,
final_second_invlet_state ) );
REQUIRE( final_first->typeId() == tshirt.typeId() );
REQUIRE( final_second->typeId() == jeans.typeId() );
CHECK( final_first_invlet_state == expected_first_invlet_state );
CHECK( final_second_invlet_state == expected_second_invlet_state );
// clear invlets
assign_invlet( dummy, *final_first, invlet, NONE );
assign_invlet( dummy, *final_second, invlet, NONE );
}
}
/* cut the currently selected way at the current cursor position */
void map_t::way_cut(lpos_t pos) {
/* check if we are still hovering above the selected way */
map_item_t *item = item_at(pos);
bool cut_at_node = item_is_selected_node(item);
if(!item_is_selected_way(item) && !cut_at_node)
return;
/* convert mouse position to canvas (world) position */
node_chain_t::iterator cut_at;
way_t *way = nullptr;
if(cut_at_node) {
printf(" cut at node\n");
/* node must not be first or last node of way */
assert(selected.object.type == object_t::WAY);
if(!selected.object.way->ends_with_node(item->object.node)) {
way = selected.object.way;
cut_at = std::find(way->node_chain.begin(), way->node_chain.end(),
item->object.node);
} else {
printf(" won't cut as it's last or first node\n");
return;
}
} else {
printf(" cut at segment\n");
int c = canvas->get_item_segment(item->item, pos);
if(c < 0)
return;
way = item->object.way;
// add one since to denote the end of the segment
cut_at = std::next(way->node_chain.begin(), c + 1);
}
assert(way != nullptr);
assert_cmpnum_op(way->node_chain.size(), >, 2);
/* move parts of node_chain to the new way */
printf(" moving everthing after segment %zi to new way\n",
cut_at - way->node_chain.begin());
/* clear selection */
item_deselect();
/* create a duplicate of the currently selected way */
way_t * const neww = way->split(appdata.project->osm, cut_at, cut_at_node);
printf("original way still has %zu nodes\n", way->node_chain.size());
/* draw the updated old way */
style->colorize(way);
draw(way);
if(neww != nullptr) {
/* colorize the new way before drawing */
style->colorize(neww);
draw(neww);
}
/* put gui into idle state */
set_action(MAP_ACTION_IDLE);
/* and redo selection if way still exists */
if(item != nullptr)
select_way(way);
else if(neww != nullptr)
select_way(neww);
}
