Merge pull request #2682 from 20k/squadwork

makeSquad, updateRoomAssignments
develop
Myk 2023-02-26 21:40:33 -08:00 committed by GitHub
commit 663b014eae
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 349 additions and 18 deletions

@ -80,11 +80,18 @@ changelog.txt uses a syntax similar to RST, with a few special sequences:
## API ## API
- ``Gui::any_civzone_hotkey``, ``Gui::getAnyCivZone``, ``Gui::getSelectedCivZone``: new functions to operate on the new zone system - ``Gui::any_civzone_hotkey``, ``Gui::getAnyCivZone``, ``Gui::getSelectedCivZone``: new functions to operate on the new zone system
- Units module: added new predicates for ``isGeldable()``, ``isMarkedForGelding()``, and ``isPet()`` - Units module: added new predicates for ``isGeldable()``, ``isMarkedForGelding()``, and ``isPet()``
- ``Military``: New module for military functionality
- ``Military``: new ``makeSquad`` to create a squad
- ``Military``: changed ``getSquadName`` to take a squad identifier
- ``Military``: new ``updateRoomAssignments`` for assigning a squad to a barracks and archery range
- ``Maps::GetBiomeType`` renamed to ``Maps::getBiomeType`` for consistency
- ``Maps::GetBiomeTypeRef`` renamed to ``Maps::getBiomeTypeRef`` for consistency
## Lua ## Lua
- ``dfhack.gui.getSelectedCivZone``: returns the Zone that the user has selected currently - ``dfhack.gui.getSelectedCivZone``: returns the Zone that the user has selected currently
- ``widgets.FilteredList``: Added ``edit_on_change`` optional parameter to allow a custom callback on filter edit change. - ``widgets.FilteredList``: Added ``edit_on_change`` optional parameter to allow a custom callback on filter edit change.
- ``widgets.TabBar``: new library widget (migrated from control-panel.lua) - ``widgets.TabBar``: new library widget (migrated from control-panel.lua)
- ``maps.getBiomeType``: exposed preexisting function to Lua
# 50.07-alpha1 # 50.07-alpha1

@ -1589,6 +1589,24 @@ Units module
Returns a table of the cutoffs used by the above stress level functions. Returns a table of the cutoffs used by the above stress level functions.
Military module
~~~~~~~~~~~~~~~~~~~
* ``dfhack.military.makeSquad(assignment_id)``
Creates a new squad associated with the assignment (ie ``df::entity_position_assignment``, via ``id``) and returns it.
Fails if a squad already exists that is associated with that assignment, or if the assignment is not a fort mode player controlled squad.
Note: This function does not name the squad: consider setting a nickname (under ``squad.name.nickname``), and/or filling out the ``language_name`` object at ``squad.name``.
The returned squad is otherwise complete and requires no more setup to work correctly.
* ``dfhack.military.updateRoomAssignments(squad_id, assignment_id, squad_use_flags)``
Sets the sleep, train, indiv_eq, and squad_eq flags when training at a barracks.
* ``dfhack.military.getSquadName(squad_id)``
Returns the name of a squad as a string.
Action Timer API Action Timer API
~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~

@ -137,6 +137,7 @@ set(MODULE_HEADERS
include/modules/MapCache.h include/modules/MapCache.h
include/modules/Maps.h include/modules/Maps.h
include/modules/Materials.h include/modules/Materials.h
include/modules/Military.h
include/modules/Once.h include/modules/Once.h
include/modules/Persistence.h include/modules/Persistence.h
include/modules/Random.h include/modules/Random.h
@ -164,6 +165,7 @@ set(MODULE_SOURCES
modules/MapCache.cpp modules/MapCache.cpp
modules/Maps.cpp modules/Maps.cpp
modules/Materials.cpp modules/Materials.cpp
modules/Military.cpp
modules/Once.cpp modules/Once.cpp
modules/Persistence.cpp modules/Persistence.cpp
modules/Random.cpp modules/Random.cpp

@ -55,6 +55,7 @@ distribution.
#include "modules/MapCache.h" #include "modules/MapCache.h"
#include "modules/Maps.h" #include "modules/Maps.h"
#include "modules/Materials.h" #include "modules/Materials.h"
#include "modules/Military.h"
#include "modules/Random.h" #include "modules/Random.h"
#include "modules/Screen.h" #include "modules/Screen.h"
#include "modules/Textures.h" #include "modules/Textures.h"
@ -1812,7 +1813,6 @@ static const LuaWrapper::FunctionReg dfhack_units_module[] = {
WRAPM(Units, getGoalType), WRAPM(Units, getGoalType),
WRAPM(Units, getGoalName), WRAPM(Units, getGoalName),
WRAPM(Units, isGoalAchieved), WRAPM(Units, isGoalAchieved),
WRAPM(Units, getSquadName),
WRAPM(Units, getPhysicalDescription), WRAPM(Units, getPhysicalDescription),
WRAPM(Units, getRaceName), WRAPM(Units, getRaceName),
WRAPM(Units, getRaceNamePlural), WRAPM(Units, getRaceNamePlural),
@ -1937,6 +1937,15 @@ static const luaL_Reg dfhack_units_funcs[] = {
{ NULL, NULL } { NULL, NULL }
}; };
/***** Military Module *****/
static const LuaWrapper::FunctionReg dfhack_military_module[] = {
WRAPM(Military, makeSquad),
WRAPM(Military, updateRoomAssignments),
WRAPM(Military, getSquadName),
{ NULL, NULL }
};
/***** Items module *****/ /***** Items module *****/
static bool items_moveToGround(df::item *item, df::coord pos) static bool items_moveToGround(df::item *item, df::coord pos)
@ -3447,6 +3456,7 @@ void OpenDFHackApi(lua_State *state)
OpenModule(state, "job", dfhack_job_module, dfhack_job_funcs); OpenModule(state, "job", dfhack_job_module, dfhack_job_funcs);
OpenModule(state, "textures", dfhack_textures_module); OpenModule(state, "textures", dfhack_textures_module);
OpenModule(state, "units", dfhack_units_module, dfhack_units_funcs); OpenModule(state, "units", dfhack_units_module, dfhack_units_funcs);
OpenModule(state, "military", dfhack_military_module);
OpenModule(state, "items", dfhack_items_module, dfhack_items_funcs); OpenModule(state, "items", dfhack_items_module, dfhack_items_funcs);
OpenModule(state, "maps", dfhack_maps_module, dfhack_maps_funcs); OpenModule(state, "maps", dfhack_maps_module, dfhack_maps_funcs);
OpenModule(state, "world", dfhack_world_module, dfhack_world_funcs); OpenModule(state, "world", dfhack_world_module, dfhack_world_funcs);

@ -0,0 +1,18 @@
#pragma once
#include "Export.h"
#include "DataDefs.h"
#include "df/squad.h"
namespace DFHack
{
namespace Military
{
DFHACK_EXPORT std::string getSquadName(int32_t squad_id);
DFHACK_EXPORT df::squad* makeSquad(int32_t assignment_id);
DFHACK_EXPORT void updateRoomAssignments(int32_t squad_id, int32_t civzone_id, df::squad_use_flags flags);
}
}

@ -222,8 +222,6 @@ DFHACK_EXPORT df::goal_type getGoalType(df::unit *unit, size_t goalIndex = 0);
DFHACK_EXPORT std::string getGoalName(df::unit *unit, size_t goalIndex = 0); DFHACK_EXPORT std::string getGoalName(df::unit *unit, size_t goalIndex = 0);
DFHACK_EXPORT bool isGoalAchieved(df::unit *unit, size_t goalIndex = 0); DFHACK_EXPORT bool isGoalAchieved(df::unit *unit, size_t goalIndex = 0);
DFHACK_EXPORT std::string getSquadName(df::unit *unit);
DFHACK_EXPORT df::activity_entry *getMainSocialActivity(df::unit *unit); DFHACK_EXPORT df::activity_entry *getMainSocialActivity(df::unit *unit);
DFHACK_EXPORT df::activity_event *getMainSocialEvent(df::unit *unit); DFHACK_EXPORT df::activity_event *getMainSocialEvent(df::unit *unit);

@ -0,0 +1,291 @@
#include <string>
#include <vector>
#include <array>
#include "MiscUtils.h"
#include "modules/Military.h"
#include "modules/Translation.h"
#include "df/building.h"
#include "df/building_civzonest.h"
#include "df/historical_figure.h"
#include "df/historical_entity.h"
#include "df/entity_position.h"
#include "df/entity_position_assignment.h"
#include "df/plotinfost.h"
#include "df/squad.h"
#include "df/squad_position.h"
#include "df/squad_schedule_order.h"
#include "df/squad_order.h"
#include "df/squad_order_trainst.h"
#include "df/world.h"
using namespace DFHack;
using namespace df::enums;
using df::global::world;
using df::global::plotinfo;
std::string Military::getSquadName(int32_t squad_id)
{
df::squad *squad = df::squad::find(squad_id);
if (!squad)
return "";
if (squad->alias.size() > 0)
return squad->alias;
return Translation::TranslateName(&squad->name, true);
}
//only works for making squads for fort mode player controlled dwarf squads
//could be extended straightforwardly by passing in entity
df::squad* Military::makeSquad(int32_t assignment_id)
{
if (df::global::squad_next_id == nullptr || df::global::plotinfo == nullptr)
return nullptr;
df::language_name name;
name.type = df::language_name_type::Squad;
for (int i=0; i < 7; i++)
{
name.words[i] = -1;
name.parts_of_speech[i] = df::part_of_speech::Noun;
}
df::historical_entity* fort = df::historical_entity::find(df::global::plotinfo->group_id);
if (fort == nullptr)
return nullptr;
df::entity_position_assignment* found_assignment = nullptr;
for (auto* assignment : fort->positions.assignments)
{
if (assignment->id == assignment_id)
{
found_assignment = assignment;
break;
}
}
if (found_assignment == nullptr)
return nullptr;
//this function does not attempt to delete or replace squads for assignments
if (found_assignment->squad_id != -1)
return nullptr;
df::entity_position* corresponding_position = nullptr;
for (auto* position : fort->positions.own)
{
if (position->id == found_assignment->position_id)
{
corresponding_position = position;
break;
}
}
if (corresponding_position == nullptr)
return nullptr;
df::squad* result = new df::squad();
result->id = *df::global::squad_next_id;
result->uniform_priority = result->id + 1; //no idea why, but seems to hold
result->carry_food = 2;
result->carry_water = 1;
result->entity_id = df::global::plotinfo->group_id;
result->leader_position = corresponding_position->id;
result->leader_assignment = found_assignment->id;
result->name = name;
int16_t squad_size = corresponding_position->squad_size;
for (int i=0; i < squad_size; i++)
{
//construct for squad_position seems to set all the attributes correctly
df::squad_position* pos = new df::squad_position();
result->positions.push_back(pos);
}
const auto& routines = df::global::plotinfo->alerts.routines;
for (const auto& routine : routines)
{
df::squad_schedule_entry* asched = (df::squad_schedule_entry*)malloc(sizeof(df::squad_schedule_entry) * 12);
for(int kk=0; kk < 12; kk++)
{
new (&asched[kk]) df::squad_schedule_entry;
for(int jj=0; jj < squad_size; jj++)
{
int32_t* order_assignments = new int32_t();
*order_assignments = -1;
asched[kk].order_assignments.push_back(order_assignments);
}
}
auto insert_training_order = [asched, squad_size](int month)
{
df::squad_schedule_order* order = new df::squad_schedule_order();
order->min_count = squad_size;
//assumed
order->positions.resize(squad_size);
df::squad_order* s_order = df::allocate<df::squad_order_trainst>();
s_order->year = *df::global::cur_year;
s_order->year_tick = *df::global::cur_year_tick;
order->order = s_order;
asched[month].orders.push_back(order);
//wear uniform while training
asched[month].uniform_mode = 0;
};
//Dwarf fortress does do this via a series of string comparisons
//Off duty: No orders, Sleep/room at will. Equip/orders only
if (routine->name == "Off duty")
{
for (int i=0; i < 12; i++)
{
asched[i].sleep_mode = 0;
asched[i].uniform_mode = 1;
}
}
//Staggered Training: Training orders at months 3 4 5 9 10 11, *or* 0 1 2 6 7 8, sleep/room at will. Equip/orders only, except train months which are equip/always
else if (routine->name == "Staggered training")
{
//this is semi randomised for different squads
//appears to be something like squad.id & 1, it isn't smart
//if you alternate squad creation, its 'correctly' staggered
//but it'll also happily not stagger them if you eg delete a squad and make another
std::array<int, 6> indices;
if ((*df::global::squad_next_id) & 1)
{
indices = {3, 4, 5, 9, 10, 11};
}
else
{
indices = {0, 1, 2, 6, 7, 8};
}
for (int index : indices)
{
insert_training_order(index);
//still sleep in room at will even when training
asched[index].sleep_mode = 0;
}
}
//see above, but with all indices
else if (routine->name == "Constant training")
{
for (int i=0; i < 12; i++)
{
insert_training_order(i);
//still sleep in room at will even when training
asched[i].sleep_mode = 0;
}
}
else if (routine->name == "Ready")
{
for (int i=0; i < 12; i++)
{
asched[i].sleep_mode = 2;
asched[i].uniform_mode = 0;
}
}
else
{
for (int i=0; i < 12; i++)
{
asched[i].sleep_mode = 0;
asched[i].uniform_mode = 0;
}
}
result->schedule.push_back(reinterpret_cast<df::squad::T_schedule*>(asched));
}
//Modify necessary world state
(*df::global::squad_next_id)++;
fort->squads.push_back(result->id);
df::global::world->squads.all.push_back(result);
found_assignment->squad_id = result->id;
return result;
}
void Military::updateRoomAssignments(int32_t squad_id, int32_t civzone_id, df::squad_use_flags flags)
{
df::squad* squad = df::squad::find(squad_id);
df::building* bzone = df::building::find(civzone_id);
df::building_civzonest* zone = strict_virtual_cast<df::building_civzonest>(bzone);
if (squad == nullptr || zone == nullptr)
return;
df::squad::T_rooms* room_from_squad = nullptr;
df::building_civzonest::T_squad_room_info* room_from_building = nullptr;
for (auto room : squad->rooms)
{
if (room->building_id == civzone_id)
{
room_from_squad = room;
break;
}
}
for (auto room : zone->squad_room_info)
{
if (room->squad_id == squad_id)
{
room_from_building = room;
break;
}
}
if (flags.whole == 0 && room_from_squad == nullptr && room_from_building == nullptr)
return;
//if we're setting 0 flags, and there's no room already, don't set a room
bool avoiding_squad_roundtrip = flags.whole == 0 && room_from_squad == nullptr;
if (!avoiding_squad_roundtrip && room_from_squad == nullptr)
{
room_from_squad = new df::squad::T_rooms();
room_from_squad->building_id = civzone_id;
insert_into_vector(squad->rooms, &df::squad::T_rooms::building_id, room_from_squad);
}
if (room_from_building == nullptr)
{
room_from_building = new df::building_civzonest::T_squad_room_info();
room_from_building->squad_id = squad_id;
insert_into_vector(zone->squad_room_info, &df::building_civzonest::T_squad_room_info::squad_id, room_from_building);
}
if (room_from_squad)
room_from_squad->mode = flags;
room_from_building->mode = flags;
if (flags.whole == 0 && !avoiding_squad_roundtrip)
{
for (int i=0; i < (int)squad->rooms.size(); i++)
{
if (squad->rooms[i]->building_id == civzone_id)
{
delete squad->rooms[i];
squad->rooms.erase(squad->rooms.begin() + i);
i--;
}
}
}
}

@ -71,7 +71,6 @@ using namespace std;
#include "df/identity.h" #include "df/identity.h"
#include "df/job.h" #include "df/job.h"
#include "df/nemesis_record.h" #include "df/nemesis_record.h"
#include "df/squad.h"
#include "df/tile_occupancy.h" #include "df/tile_occupancy.h"
#include "df/plotinfost.h" #include "df/plotinfost.h"
#include "df/unit_inventory_item.h" #include "df/unit_inventory_item.h"
@ -1959,19 +1958,6 @@ bool Units::isGoalAchieved(df::unit *unit, size_t goalIndex)
&& unit->status.current_soul->personality.dreams[goalIndex]->flags.whole != 0; && unit->status.current_soul->personality.dreams[goalIndex]->flags.whole != 0;
} }
std::string Units::getSquadName(df::unit *unit)
{
CHECK_NULL_POINTER(unit);
if (unit->military.squad_id == -1)
return "";
df::squad *squad = df::squad::find(unit->military.squad_id);
if (!squad)
return "";
if (squad->alias.size() > 0)
return squad->alias;
return Translation::TranslateName(&squad->name, true);
}
df::activity_entry *Units::getMainSocialActivity(df::unit *unit) df::activity_entry *Units::getMainSocialActivity(df::unit *unit)
{ {
CHECK_NULL_POINTER(unit); CHECK_NULL_POINTER(unit);

@ -8,6 +8,7 @@
#include <modules/Screen.h> #include <modules/Screen.h>
#include <modules/Translation.h> #include <modules/Translation.h>
#include <modules/Units.h> #include <modules/Units.h>
#include <modules/Military.h>
#include <modules/Filesystem.h> #include <modules/Filesystem.h>
#include <modules/Job.h> #include <modules/Job.h>
#include <vector> #include <vector>
@ -1305,7 +1306,7 @@ void viewscreen_unitlaborsst::refreshNames()
cur->job_mode = UnitInfo::JOB; cur->job_mode = UnitInfo::JOB;
} }
if (unit->military.squad_id > -1) { if (unit->military.squad_id > -1) {
cur->squad_effective_name = Units::getSquadName(unit); cur->squad_effective_name = Military::getSquadName(unit->military.squad_id);
cur->squad_info = stl_sprintf("%i", unit->military.squad_position + 1) + "." + cur->squad_effective_name; cur->squad_info = stl_sprintf("%i", unit->military.squad_position + 1) + "." + cur->squad_effective_name;
} else { } else {
cur->squad_effective_name = ""; cur->squad_effective_name = "";