void activity_on_turn_move_items()
{
// Move activity has source square, target square,
// indices of items on map, and quantities of same.
point source = g->u.activity.placement;
point destination = point( g->u.activity.values[0], g->u.activity.values[1] );
std::list<int> indices;
std::list<int> quantities;
// Note i = 2, skipping first few elements.
for( size_t i = 2; i < g->u.activity.values.size(); i += 2 ) {
indices.push_back( g->u.activity.values[i] );
quantities.push_back( g->u.activity.values[ i + 1 ] );
}
// Nuke the current activity, leaving the backlog alone.
g->u.activity = player_activity();
move_items( source, destination, indices, quantities );
if( !indices.empty() ) {
g->u.assign_activity( ACT_MOVE_ITEMS, 0 );
g->u.activity.placement = source;
g->u.activity.values.push_back( destination.x );
g->u.activity.values.push_back( destination.y );
while( !indices.empty() ) {
g->u.activity.values.push_back( indices.front() );
indices.pop_front();
g->u.activity.values.push_back( quantities.front() );
quantities.pop_front();
}
}
}
/**
* rotate the currently selected on the sheet
*/
void sheet_move_selection (Sheet *sheet, gdouble x, gdouble y)
{
g_return_if_fail (sheet != NULL);
g_return_if_fail (IS_SHEET (sheet));
const Coords delta = {x, y};
if (sheet->priv->selected_objects != NULL)
move_items (sheet, sheet->priv->selected_objects, &delta);
}
void*
BList::RemoveItem(int32 index)
{
void* item = NULL;
if (index >= 0 && index < fItemCount) {
item = fObjectList[index];
move_items(fObjectList + index + 1, -1, fItemCount - index - 1);
--fItemCount;
if (fItemCount <= fResizeThreshold)
_ResizeArray(fItemCount);
}
return item;
}
bool
BList::AddList(const BList* list, int32 index)
{
bool result = (list && index >= 0 && index <= fItemCount);
if (result && list->fItemCount > 0) {
int32 count = list->fItemCount;
if (fItemCount + count > fPhysicalSize)
result = _ResizeArray(fItemCount + count);
if (result) {
fItemCount += count;
move_items(fObjectList + index, count, fItemCount - index - count);
memcpy(fObjectList + index, list->fObjectList,
list->fItemCount * sizeof(void*));
}
}
return result;
}
bool
BList::AddItem(void* item, int32 index)
{
if (index < 0 || index > fItemCount)
return false;
bool result = true;
if (fItemCount + 1 > fPhysicalSize)
result = _ResizeArray(fItemCount + 1);
if (result) {
++fItemCount;
move_items(fObjectList + index, 1, fItemCount - index - 1);
fObjectList[index] = item;
}
return result;
}
bool
BList::RemoveItems(int32 index, int32 count)
{
bool result = (index >= 0 && index <= fItemCount);
if (result) {
if (index + count > fItemCount)
count = fItemCount - index;
if (count > 0) {
move_items(fObjectList + index + count, -count,
fItemCount - index - count);
fItemCount -= count;
if (fItemCount <= fResizeThreshold)
_ResizeArray(fItemCount);
} else
result = false;
}
return result;
}
/* values explanation
* 0: items from vehicle?
* 1: items to a vehicle?
* 2: index <-+
* 3: amount |
* n: ^-------+
*/
void activity_on_turn_move_items()
{
// Drop activity if we don't know destination coordinates.
if( g->u.activity.coords.empty() ) {
g->u.activity = player_activity();
return;
}
// Move activity has source square, target square,
// indices of items on map, and quantities of same.
const tripoint destination = g->u.activity.coords[0];
const tripoint source = g->u.activity.placement;
bool from_vehicle = g->u.activity.values[0];
bool to_vehicle = g->u.activity.values[1];
std::list<int> indices;
std::list<int> quantities;
// Note i = 4, skipping first few elements.
for( size_t i = 2; i < g->u.activity.values.size(); i += 2 ) {
indices.push_back( g->u.activity.values[i] );
quantities.push_back( g->u.activity.values[i + 1] );
}
// Nuke the current activity, leaving the backlog alone.
g->u.activity = player_activity();
// *puts on 3d glasses from 90s cereal box*
move_items( source, from_vehicle, destination, to_vehicle, indices, quantities );
if( !indices.empty() ) {
g->u.assign_activity( activity_id( "ACT_MOVE_ITEMS" ) );
g->u.activity.placement = source;
g->u.activity.coords.push_back( destination );
g->u.activity.values.push_back( from_vehicle );
g->u.activity.values.push_back( to_vehicle );
while( !indices.empty() ) {
g->u.activity.values.push_back( indices.front() );
indices.pop_front();
g->u.activity.values.push_back( quantities.front() );
quantities.pop_front();
}
}
}
void try_fuel_fire( player_activity &act, player &p, const bool starting_fire )
{
const tripoint pos = p.pos();
auto adjacent = closest_tripoints_first( PICKUP_RANGE, pos );
adjacent.erase( adjacent.begin() );
cata::optional<tripoint> best_fire = starting_fire ? act.placement : find_best_fire( adjacent,
pos );
if( !best_fire || !g->m.accessible_items( *best_fire ) ) {
return;
}
const auto refuel_spot = std::find_if( adjacent.begin(), adjacent.end(),
[pos]( const tripoint & pt ) {
// Hacky - firewood spot is a trap and it's ID-checked
// TODO: Something cleaner than ID-checking a trap
return g->m.tr_at( pt ).id == tr_firewood_source && g->m.has_items( pt ) &&
g->m.accessible_items( pt ) && g->m.clear_path( pos, pt, PICKUP_RANGE, 1, 100 );
} );
if( refuel_spot == adjacent.end() ) {
return;
}
// Special case: fire containers allow burning logs, so use them as fuel iif fire is contained
bool contained = g->m.has_flag_furn( TFLAG_FIRE_CONTAINER, *best_fire );
fire_data fd( 1, contained );
time_duration fire_age = g->m.get_field_age( *best_fire, fd_fire );
// Maybe TODO: - refuelling in the rain could use more fuel
// First, simulate expected burn per turn, to see if we need more fuel
auto fuel_on_fire = g->m.i_at( *best_fire );
for( size_t i = 0; i < fuel_on_fire.size(); i++ ) {
fuel_on_fire[i].simulate_burn( fd );
// Uncontained fires grow below -50_minutes age
if( !contained && fire_age < -40_minutes && fd.fuel_produced > 1.0f &&
!fuel_on_fire[i].made_of( LIQUID ) ) {
// Too much - we don't want a firestorm!
// Put first item back to refuelling pile
std::list<int> indices_to_remove{ static_cast<int>( i ) };
std::list<int> quantities_to_remove{ 0 };
move_items( p, *best_fire - pos, false, *refuel_spot - pos, false, indices_to_remove,
quantities_to_remove );
return;
}
}
// Enough to sustain the fire
// TODO: It's not enough in the rain
if( !starting_fire && ( fd.fuel_produced >= 1.0f || fire_age < 10_minutes ) ) {
return;
}
// We need to move fuel from stash to fire
auto potential_fuel = g->m.i_at( *refuel_spot );
for( size_t i = 0; i < potential_fuel.size(); i++ ) {
if( potential_fuel[i].made_of( LIQUID ) ) {
continue;
}
float last_fuel = fd.fuel_produced;
potential_fuel[i].simulate_burn( fd );
if( fd.fuel_produced > last_fuel ) {
std::list<int> indices{ static_cast<int>( i ) };
std::list<int> quantities{ 0 };
// Note: move_items handles messages (they're the generic "you drop x")
move_items( p, *refuel_spot - p.pos(), false, *best_fire - p.pos(), false, indices,
quantities );
return;
}
}
}
// motion_notify_event: When the mouse pointer is moved over the map area
// ------------------------------------------------------------------- >>
static gboolean motion_notify_event(GtkWidget *widget, GdkEventMotion *event)
{
int x, y;
bool redraw_map = false;
bool update_map = false;
GdkModifierType state;
if (event->is_hint)
{
gdk_window_get_pointer(event->window, &x, &y, &state);
}
else
{
x = event->x;
y = event->y;
state = (GdkModifierType)(event->state);
}
mouse.set(x, y);
// Selection box
if (sel_box.x1() != -1)
{
sel_box.br.set(x, y);
if (line_draw)
line_drawbox();
redraw_map = true;
}
else
{
if (binds.pressed("edit_selectbox"))
{
sel_box.tl.set(down_pos);
sel_box.br.set(down_pos);
//binds.clear("edit_selectbox");
}
}
// Moving items
if (items_moving)
{
move_items();
redraw_map = update_map = true;
}
else
{
if (binds.pressed("edit_moveitems") && (selection() || hilight_item != -1))
{
items_moving = true;
add_move_items();
//binds.clear("edit_moveitems");
redraw_map = update_map = true;
}
}
// Quick thing angle
if (thing_quickangle)
{
thing_setquickangle();
redraw_map = update_map = true;
}
else
{
if (binds.pressed("thing_quickangle"))
{
make_backup(false, false, false, false, true);
thing_quickangle = true;
thing_setquickangle();
redraw_map = update_map = true;
//binds.clear("thing_quickangle");
}
}
/*
if (state & GDK_BUTTON3_MASK)
{
if (items_moving)
{
move_items();
redraw_map = true;
update_map = true;
}
else
{
add_move_items();
items_moving = true;
redraw_map = update_map = true;
}
}
if (state & GDK_BUTTON2_MASK)
{
// Quick thing angle
thing_quickangle = true;
thing_setquickangle();
redraw_map = true;
update_map = true;
}
if (sel_box.x1() != -1)
{
sel_box.br.set(x, y);
if (line_draw)
line_drawbox();
redraw_map = true;
}
else
{
if (line_draw || paste_mode)
redraw_map = true;
if (!thing_quickangle && !paste_mode)
{
int old_hilight = hilight_item;
get_hilight_item(x, y);
if (hilight_item != old_hilight)
redraw_map = true;
}
}
*/
if (line_draw || paste_mode)
redraw_map = true;
if (!thing_quickangle && !paste_mode && !line_draw && sel_box.x1() == -1)
{
int old_hilight = hilight_item;
get_hilight_item(x, y);
if (hilight_item != old_hilight)
redraw_map = true;
}
//if (redraw_map)
force_map_redraw(update_map);
update_status_bar();
return TRUE;
}
