Lucas de Vries
1334 lines
32 KiB
ActionScript
1334 lines
32 KiB
ActionScript
import systems;
|
|
import navigation.SmartCamera;
|
|
from navigation.elevation import getElevationIntersect, getElevation;
|
|
from input import activeCamera;
|
|
import ftl;
|
|
import tabs.Tab;
|
|
import orbitals;
|
|
import orders;
|
|
import resources;
|
|
import abilities;
|
|
import buildings;
|
|
from hooks import Hook;
|
|
from generic_effects import AddTurret, GenericRepeatHook, ShowsRange, IfHook;
|
|
from targeting.targeting import hoverFilter, lastHoverFilter;
|
|
|
|
bool debugCursor = false;
|
|
double get_DOUBLECLICK_TIME() {
|
|
return double(settings::iDoubleClickMS) / 1000.0;
|
|
}
|
|
const double HOVER_CONE_SLOPE = 0.02;
|
|
|
|
import void targetMovement() from "targeting.MoveTarget";
|
|
import bool canMove(Object& obj) from "targeting.MoveTarget";
|
|
import Tab@ get_ActiveTab() from "tabs.tabbar";
|
|
import bool isGuiHovered() from "gui";
|
|
import void pinObject(Tab@ _tab, Object@ obj, bool floating) from "tabs.GalaxyTab";
|
|
import void zoomTabTo(Object@ obj) from "tabs.GalaxyTab";
|
|
import void openOverlay(Object@ obj) from "tabs.GalaxyTab";
|
|
import void openSupportOverlay(Object@ obj) from "tabs.GalaxyTab";
|
|
|
|
set_int selectedIDs;
|
|
array<Object@> selection;
|
|
array<array<Object@>> groups(9);
|
|
Object@ hovered;
|
|
Object@ uiobj;
|
|
|
|
vec2i lastMousePos;
|
|
|
|
Object@ get_hoveredObject() {
|
|
if(lastMousePos != mousePos || hoverFilter !is lastHoverFilter)
|
|
updateHoveredObject();
|
|
return hovered;
|
|
}
|
|
|
|
Object@ get_uiObject() {
|
|
return uiobj;
|
|
}
|
|
|
|
void set_uiObject(Object@ obj) {
|
|
@uiobj = obj;
|
|
}
|
|
|
|
array<Object@>@ get_selectedObjects() {
|
|
return selection;
|
|
}
|
|
|
|
Object@ get_selectedObject() {
|
|
if(selection.length == 0)
|
|
return null;
|
|
return selection[0];
|
|
}
|
|
|
|
bool isSelected(Object@ obj) {
|
|
return selectedIDs.contains(obj.id);
|
|
}
|
|
|
|
void selectObject(Object@ obj) {
|
|
if(ctrlKey)
|
|
toggleObjectSelect(obj);
|
|
else
|
|
selectObject(obj, shiftKey);
|
|
}
|
|
|
|
void deselectObject(Object@ obj) {
|
|
obj.selected = false;
|
|
selection.remove(obj);
|
|
selectedIDs.erase(obj.id);
|
|
updateBeams();
|
|
}
|
|
|
|
void clearSelection() {
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i)
|
|
selection[i].selected = false;
|
|
selection.length = 0;
|
|
selectedIDs.clear();
|
|
}
|
|
|
|
void addToSelection(Object@ obj) {
|
|
if(!selectedIDs.contains(obj.id)) {
|
|
obj.selected = true;
|
|
selection.insertLast(obj);
|
|
selectedIDs.insert(obj.id);
|
|
}
|
|
}
|
|
|
|
void toggleObjectSelect(Object@ obj) {
|
|
if(obj is null)
|
|
return;
|
|
if(isSelected(obj))
|
|
deselectObject(obj);
|
|
else
|
|
selectObject(obj, true);
|
|
}
|
|
|
|
void selectObject(Object@ obj, bool add) {
|
|
if(obj is null) {
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i)
|
|
selection[i].selected = false;
|
|
selection.length = 0;
|
|
selectedIDs.clear();
|
|
}
|
|
else if(!add) {
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i)
|
|
selection[i].selected = false;
|
|
if(ctrlKey) {
|
|
selection.length = 1;
|
|
@selection[0] = obj;
|
|
obj.selected = true;
|
|
selectedIDs.clear();
|
|
selectedIDs.insert(obj.id);
|
|
}
|
|
else {
|
|
if(obj !is null) {
|
|
obj.selected = true;
|
|
selection.length = 1;
|
|
@selection[0] = obj;
|
|
selectedIDs.clear();
|
|
selectedIDs.insert(obj.id);
|
|
}
|
|
else {
|
|
selection.length = 0;
|
|
selectedIDs.clear();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if(ctrlKey) {
|
|
if(!selectedIDs.contains(obj.id)) {
|
|
obj.selected = true;
|
|
selection.insertLast(obj);
|
|
selectedIDs.insert(obj.id);
|
|
}
|
|
}
|
|
else {
|
|
if(obj !is null && !selectedIDs.contains(obj.id)) {
|
|
obj.selected = true;
|
|
selection.insertLast(obj);
|
|
selectedIDs.insert(obj.id);
|
|
}
|
|
}
|
|
}
|
|
updateBeams();
|
|
}
|
|
|
|
int getSelectionScale() {
|
|
int scale = 0;
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
|
|
Ship@ ship = cast<Ship>(selection[i]);
|
|
if(ship is null)
|
|
continue;
|
|
int shipScale = ship.blueprint.design.size;
|
|
scale += shipScale;
|
|
}
|
|
return scale;
|
|
}
|
|
|
|
vec3d getSelectionPosition(bool onlyMovable = false) {
|
|
vec3d pos;
|
|
uint j = 0;
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
|
|
Object@ obj = selection[i];
|
|
if(onlyMovable) {
|
|
if(!obj.hasMover || !obj.owner.controlled)
|
|
continue;
|
|
}
|
|
pos += selection[i].position;
|
|
++j;
|
|
}
|
|
if(j != 0)
|
|
pos /= j;
|
|
return pos;
|
|
}
|
|
|
|
Object@ pressedObject;
|
|
double pressedTime;
|
|
|
|
void selectionClick(uint button, bool pressed) {
|
|
Object@ Hovered = hoveredObject;
|
|
bool doubleClicked = false;
|
|
|
|
//Send clicks to the tab
|
|
if(!pressed) {
|
|
//Check for double clicks
|
|
if(button == 0 && Hovered !is null) {
|
|
sound::objselect.play(priority=true);
|
|
double now = frameTime;
|
|
if(pressedObject is Hovered) {
|
|
if(pressedTime > now - DOUBLECLICK_TIME) {
|
|
doubleClicked = true;
|
|
@pressedObject = null;
|
|
}
|
|
}
|
|
else {
|
|
@pressedObject = Hovered;
|
|
}
|
|
pressedTime = now;
|
|
}
|
|
|
|
//Check for pings
|
|
if(altKey && activeCamera !is null && button == 0) {
|
|
vec3d pingPos;
|
|
if(Hovered !is null)
|
|
pingPos = Hovered.node_position;
|
|
else
|
|
pingPos = activeCamera.screenToPoint(mousePos);
|
|
uint pingType = 0;
|
|
if(ctrlKey)
|
|
pingType = 1;
|
|
if(shiftKey)
|
|
sendPingAll(pingPos, pingType);
|
|
else
|
|
sendPingAllied(pingPos, pingType);
|
|
return;
|
|
}
|
|
|
|
Tab@ activeTab = ActiveTab;
|
|
if(activeTab !is null && Hovered !is null)
|
|
if(activeTab.objectInteraction(Hovered, button, doubleClicked))
|
|
return;
|
|
|
|
//Actual object selection
|
|
if(button == 0) {
|
|
if(Hovered !is null || !(ctrlKey || shiftKey)) {
|
|
if(ctrlKey)
|
|
toggleObjectSelect(Hovered);
|
|
else
|
|
selectObject(Hovered, shiftKey);
|
|
}
|
|
}
|
|
}
|
|
//Go into movement targeting mode
|
|
else if(button == 1 && Hovered is null) {
|
|
if(selection.length != 0) {
|
|
bool hasMovement = false;
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
|
|
Object@ obj = selection[i];
|
|
if(canMove(obj)) {
|
|
hasMovement = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(hasMovement)
|
|
targetMovement();
|
|
}
|
|
}
|
|
}
|
|
|
|
enum SelectionType {
|
|
ST_Military,
|
|
ST_Civilian,
|
|
ST_Fleets,
|
|
ST_Planets,
|
|
ST_Other
|
|
};
|
|
|
|
SelectionType classifyRestrictive(array<Object@>& objs) {
|
|
uint type = ST_Other;
|
|
|
|
for(uint i = 0, cnt = objs.length; i < cnt; ++i) {
|
|
Object@ obj = objs[i];
|
|
if(!obj.owner.controlled)
|
|
continue;
|
|
|
|
uint newType = ST_Other;
|
|
switch(obj.type) {
|
|
case OT_Ship:
|
|
//Nothing overrides ship selection
|
|
if(obj.hasLeaderAI) {
|
|
if(obj.getFleetStrength() < 1000.0)
|
|
newType = ST_Civilian;
|
|
else
|
|
newType = ST_Military;
|
|
}
|
|
break;
|
|
case OT_Planet:
|
|
newType = ST_Planets;
|
|
break;
|
|
}
|
|
|
|
if(newType < type)
|
|
type = newType;
|
|
}
|
|
|
|
return SelectionType(type);
|
|
}
|
|
|
|
SelectionType classifyRelaxed(array<Object@>& objs) {
|
|
SelectionType type = ST_Fleets;
|
|
|
|
for(uint i = 0, cnt = objs.length; i < cnt; ++i) {
|
|
Object@ obj = objs[i];
|
|
if(!obj.owner.controlled)
|
|
return ST_Other;
|
|
|
|
switch(obj.type) {
|
|
case OT_Ship:
|
|
//Nothing overrides ship selection
|
|
if(!obj.hasLeaderAI)
|
|
return ST_Other;
|
|
break;
|
|
case OT_Planet:
|
|
if(type == ST_Fleets)
|
|
type = ST_Planets;
|
|
break;
|
|
default:
|
|
return ST_Other;
|
|
}
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
void filter(array<Object@>& objs, SelectionType type) {
|
|
if(type == ST_Other)
|
|
return;
|
|
|
|
array<Object@> output;
|
|
|
|
switch(type) {
|
|
case ST_Fleets:
|
|
for(uint i = 0, cnt = objs.length; i < cnt; ++i) {
|
|
Object@ obj = objs[i];
|
|
if(!obj.owner.controlled || !obj.isShip || !obj.hasLeaderAI)
|
|
continue;
|
|
output.insertLast(obj);
|
|
}
|
|
break;
|
|
case ST_Civilian:
|
|
case ST_Military:
|
|
for(uint i = 0, cnt = objs.length; i < cnt; ++i) {
|
|
Object@ obj = objs[i];
|
|
if(!obj.owner.controlled || !obj.isShip || !obj.hasLeaderAI)
|
|
continue;
|
|
if((obj.getFleetStrength() < 1000.0) != (type == ST_Civilian))
|
|
continue;
|
|
output.insertLast(obj);
|
|
}
|
|
break;
|
|
case ST_Planets:
|
|
for(uint i = 0, cnt = objs.length; i < cnt; ++i) {
|
|
Object@ obj = objs[i];
|
|
if(!obj.owner.controlled || !obj.isPlanet)
|
|
continue;
|
|
output.insertLast(obj);
|
|
}
|
|
break;
|
|
}
|
|
|
|
objs = output;
|
|
}
|
|
|
|
|
|
void dragSelect(const recti& box) {
|
|
array<Object@> objects = activeCamera.camera.boxSelect(box);
|
|
|
|
SelectionType selType;
|
|
|
|
//If we're adding to our current selection, filter by the current selection type
|
|
if(shiftKey)
|
|
selType = classifyRelaxed(selection);
|
|
else
|
|
selType = classifyRestrictive(objects);
|
|
|
|
filter(objects, selType);
|
|
|
|
if(!shiftKey)
|
|
clearSelection();
|
|
for(uint i = 0, cnt = objects.length; i < cnt; ++i)
|
|
addToSelection(objects[i]);
|
|
|
|
updateBeams();
|
|
}
|
|
|
|
/*double getObjectMaxSelectionDistance(Object& obj) {
|
|
switch(obj.type) {
|
|
case OT_Ship:
|
|
if(obj.hasLeaderAI)
|
|
return INFINITY;
|
|
else
|
|
return 300.0 * obj.radius;
|
|
case OT_Planet:
|
|
return 16000.0;
|
|
case OT_Orbital:
|
|
return 16000.0;
|
|
case OT_Asteroid:
|
|
case OT_Anomaly:
|
|
case OT_Pickup:
|
|
return 16000.0;
|
|
case OT_ColonyShip:
|
|
return 2000.0;
|
|
case OT_Star:
|
|
return INFINITY;
|
|
}
|
|
return 16000.0;
|
|
}*/
|
|
|
|
const double MAX_SUPPORT_SELECT_DIST = 1000.0;
|
|
const double MAX_PLANET_SELECT_DIST = 52000.0;
|
|
const double MAX_PLANET_PHYS_SEL_DIST = 2000.0;
|
|
const double MAX_ORBITAL_SELECT_DIST = 52000.0;
|
|
const double MAX_PICKUP_SELECT_DIST = 20000.0;
|
|
const double MAX_COLSHIP_SELECT_DIST = 12000.0;
|
|
const double MAX_CIVILIAN_SELECT_DIST = 1500.0;
|
|
|
|
array<Node@> nodes, bestNodes;
|
|
|
|
void updateHoveredObject() {
|
|
//double start = getExactTime();
|
|
lastMousePos = mousePos;
|
|
@lastHoverFilter = hoverFilter;
|
|
|
|
//Outside of the screen, nothing to do
|
|
if(lastMousePos.x < 0 || lastMousePos.y < 0 || lastMousePos.x > screenSize.x || lastMousePos.y > screenSize.y
|
|
|| isGuiHovered()) {
|
|
@hovered = null;
|
|
}
|
|
else if(activeCamera !is null) {
|
|
line3dd line = activeCamera.screenToRay(lastMousePos);
|
|
nodeConeSelect(line, HOVER_CONE_SLOPE, nodes);
|
|
|
|
//Find best node
|
|
Node@ best = null;
|
|
double bestScore = 0;
|
|
for(uint i = 0, cnt = nodes.length; i < cnt; ++i) {
|
|
Node@ cur = nodes[i];
|
|
Object@ obj = cur.object;
|
|
if(obj is null)
|
|
continue;
|
|
|
|
double dist = cur.position.distanceTo(line.start) * config::GFX_DISTANCE_MOD;
|
|
double score = 1.0 / dist;
|
|
Empire@ owner = obj.owner;
|
|
|
|
if(hoverFilter is null) {
|
|
if(obj.selected)
|
|
score /= 10.0;
|
|
else if(owner.controlled)
|
|
score *= 1.5;
|
|
}
|
|
else {
|
|
if(!hoverFilter(obj))
|
|
score /= 10.0;
|
|
}
|
|
|
|
switch(obj.type) {
|
|
case OT_Ship:
|
|
if(!obj.hasLeaderAI) {
|
|
if(dist > MAX_SUPPORT_SELECT_DIST)
|
|
continue;
|
|
score /= 4.0;
|
|
}
|
|
if(owner !is null && !owner.major)
|
|
score /= 10.0;
|
|
break;
|
|
case OT_Planet:
|
|
if(dist > MAX_PLANET_SELECT_DIST)
|
|
continue;
|
|
//Ignore physical planets at great distances, the player will be selecting the icon instead
|
|
if(dist > MAX_PLANET_PHYS_SEL_DIST / 10.0 * obj.radius && cast<PlanetIconNode>(cur) is null)
|
|
continue;
|
|
break;
|
|
case OT_Orbital:
|
|
if(dist > MAX_ORBITAL_SELECT_DIST)
|
|
continue;
|
|
score /= 2.0;
|
|
break;
|
|
case OT_Anomaly:
|
|
case OT_Asteroid:
|
|
score /= 3.0;
|
|
break;
|
|
case OT_Pickup:
|
|
break;
|
|
case OT_ColonyShip:
|
|
if(dist > MAX_COLSHIP_SELECT_DIST)
|
|
continue;
|
|
score /= 20.0;
|
|
break;
|
|
case OT_Civilian:
|
|
if(dist > MAX_CIVILIAN_SELECT_DIST * obj.radius)
|
|
continue;
|
|
score /= 5.0;
|
|
break;
|
|
case OT_Star:
|
|
default:
|
|
score /= 6.0;
|
|
break;
|
|
}
|
|
|
|
if(score * 4.0 < bestScore)
|
|
continue;
|
|
|
|
score /= cur.position.distanceTo(line.getClosestPoint(cur.position, true));
|
|
if(score < bestScore)
|
|
continue;
|
|
|
|
@best = cur;
|
|
bestScore = score;
|
|
}
|
|
|
|
//Set hover
|
|
if(best !is null)
|
|
@hovered = best.object;
|
|
else
|
|
@hovered = null;
|
|
|
|
//Update beam shown for hovered objects
|
|
updateHoverBeams();
|
|
|
|
bestNodes.length = 0;
|
|
nodes.length = 0;
|
|
}
|
|
|
|
//double end = getExactTime();
|
|
//error("Hovered update took " + int((end - start) * 1000.0) + "ms");
|
|
}
|
|
|
|
void clearHoveredObject() {
|
|
@hovered = null;
|
|
}
|
|
|
|
class DebugCursorCommand : ConsoleCommand {
|
|
void execute(const string& args) {
|
|
debugCursor = args.length == 0 || toBool(args);
|
|
}
|
|
};
|
|
|
|
void pinObj(bool pressed) {
|
|
if(!pressed) {
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
|
|
Object@ obj = selection[i];
|
|
if(obj !is null)
|
|
pinObject(ActiveTab, obj, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void pinObjFloat(bool pressed) {
|
|
if(!pressed) {
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
|
|
Object@ obj = selection[i];
|
|
if(obj !is null)
|
|
pinObject(ActiveTab, obj, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void holdPosition(bool pressed) {
|
|
if(!pressed) {
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
|
|
Object@ obj = selection[i];
|
|
if(obj.hasLeaderAI)
|
|
obj.setHoldPosition(!shiftKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
void group_key(bool pressed, uint groupIndex) {
|
|
if(!pressed)
|
|
return;
|
|
|
|
array<Object@>@ group = groups[groupIndex];
|
|
if(ctrlKey && shiftKey) {
|
|
//Add current selection to group
|
|
if(selection.length == 0)
|
|
return;
|
|
|
|
set_int groupObjs;
|
|
for(uint i = 0, cnt = group.length; i < cnt; ++i)
|
|
groupObjs.insert(group[i].id);
|
|
for(uint i = 0, cnt = selection.length; i < cnt; ++i) {
|
|
Object@ obj = selection[i];
|
|
if(groupObjs.contains(obj.id))
|
|
continue;
|
|
group.insertLast(obj);
|
|
groupObjs.insert(obj.id);
|
|
}
|
|
|
|
sound::objselect.play(priority=true);
|
|
}
|
|
else if(shiftKey) {
|
|
//Add group to selection
|
|
for(uint i = 0, cnt = group.length; i < cnt; ++i)
|
|
addToSelection(group[i]);
|
|
|
|
if(group.length != 0)
|
|
sound::objselect.play(priority=true);
|
|
}
|
|
else if(ctrlKey) {
|
|
//Set group to selection
|
|
if(selection.length != 0) {
|
|
group = selection;
|
|
sound::objselect.play(priority=true);
|
|
}
|
|
}
|
|
else {
|
|
//Switch to selection
|
|
// If the group is already (fully) selected, instead move the camera to that group
|
|
bool sameGroup = false;
|
|
if(selection.length == group.length) {
|
|
sameGroup = true;
|
|
for(uint i = 0, cnt = group.length; i < cnt; ++i) {
|
|
if(!isSelected(group[i])) {
|
|
sameGroup = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(sameGroup) {
|
|
if(selection.length != 0)
|
|
zoomTabTo(selection[0]);
|
|
}
|
|
else {
|
|
clearSelection();
|
|
for(uint i = 0, cnt = group.length; i < cnt; ++i)
|
|
addToSelection(group[i]);
|
|
sound::objselect.play(priority=true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void group_1(bool pressed) { group_key(pressed, 0); }
|
|
void group_2(bool pressed) { group_key(pressed, 1); }
|
|
void group_3(bool pressed) { group_key(pressed, 2); }
|
|
void group_4(bool pressed) { group_key(pressed, 3); }
|
|
void group_5(bool pressed) { group_key(pressed, 4); }
|
|
void group_6(bool pressed) { group_key(pressed, 5); }
|
|
void group_7(bool pressed) { group_key(pressed, 6); }
|
|
void group_8(bool pressed) { group_key(pressed, 7); }
|
|
void group_9(bool pressed) { group_key(pressed, 8); }
|
|
|
|
bool SHOW_FIREARCS = false;
|
|
void toggleFireArcs(bool pressed) {
|
|
if(!pressed)
|
|
SHOW_FIREARCS = !SHOW_FIREARCS;
|
|
}
|
|
|
|
void manage_obj(bool pressed) {
|
|
if(!pressed) {
|
|
if(selectedObject !is null)
|
|
openOverlay(selectedObject);
|
|
else if(hoveredObject !is null)
|
|
openOverlay(hoveredObject);
|
|
}
|
|
}
|
|
|
|
void manage_support(bool pressed) {
|
|
if(!pressed) {
|
|
if(selectedObject !is null)
|
|
openSupportOverlay(selectedObject);
|
|
else if(hoveredObject !is null)
|
|
openSupportOverlay(hoveredObject);
|
|
}
|
|
}
|
|
|
|
void init() {
|
|
addConsoleCommand("debug_cursor", DebugCursorCommand());
|
|
keybinds::Global.addBind(KB_MANAGE, "manage_obj");
|
|
keybinds::Global.addBind(KB_MANAGE_SUPPORT, "manage_support");
|
|
keybinds::Global.addBind(KB_PIN, "pinObj");
|
|
keybinds::Global.addBind(KB_HOLD_POSITION, "holdPosition");
|
|
keybinds::Global.addBind(KB_PIN_FLOATING, "pinObjFloat");
|
|
keybinds::Global.addBind(KB_TOGGLE_FIREARCS, "toggleFireArcs");
|
|
hoverBeams.isHover = true;
|
|
|
|
keybinds::Global.addBind(KB_GROUP_1, "group_1");
|
|
keybinds::Global.addBind(KB_GROUP_2, "group_2");
|
|
keybinds::Global.addBind(KB_GROUP_3, "group_3");
|
|
keybinds::Global.addBind(KB_GROUP_4, "group_4");
|
|
keybinds::Global.addBind(KB_GROUP_5, "group_5");
|
|
keybinds::Global.addBind(KB_GROUP_6, "group_6");
|
|
keybinds::Global.addBind(KB_GROUP_7, "group_7");
|
|
keybinds::Global.addBind(KB_GROUP_8, "group_8");
|
|
keybinds::Global.addBind(KB_GROUP_9, "group_9");
|
|
|
|
keybinds::Global.addBind(KB_PING, "ping_allied");
|
|
keybinds::Global.addBind(KB_PING_ALL, "ping_all");
|
|
}
|
|
|
|
void ping_allied(bool pressed) {
|
|
if(pressed)
|
|
return;
|
|
|
|
vec3d pingPos;
|
|
if(hoveredObject !is null)
|
|
pingPos = hoveredObject.node_position;
|
|
else if(activeCamera !is null)
|
|
pingPos = activeCamera.screenToPoint(mousePos);
|
|
else
|
|
return;
|
|
|
|
uint pingType = 0;
|
|
if(ctrlKey)
|
|
pingType = 1;
|
|
|
|
sendPingAllied(pingPos, pingType);
|
|
}
|
|
|
|
void ping_all(bool pressed) {
|
|
if(pressed)
|
|
return;
|
|
|
|
vec3d pingPos;
|
|
if(hoveredObject !is null)
|
|
pingPos = hoveredObject.node_position;
|
|
else if(activeCamera !is null)
|
|
pingPos = activeCamera.screenToPoint(mousePos);
|
|
else
|
|
return;
|
|
|
|
uint pingType = 0;
|
|
if(ctrlKey)
|
|
pingType = 1;
|
|
|
|
sendPingAll(pingPos, pingType);
|
|
}
|
|
|
|
const Color MOVE_BEAM_COLOR(0x00ff00ff);
|
|
const Color RALLY_BEAM_COLOR(0x00ffaaff);
|
|
const Color FTL_BEAM_COLOR(0x00c0ffff);
|
|
const Color HEIGHT_BEAM_COLOR(0xaaaaaaff);
|
|
const Color IMPORT_BEAM_COLOR(0x0000ffff);
|
|
const Color EXPORT_BEAM_COLOR(0x76e0e0ff);
|
|
const Color QUEUED_EXPORT_BEAM_COLOR(0xffe400ff);
|
|
const Color QUEUED_IMPORT_BEAM_COLOR(0xffe400ff);
|
|
const Color LINK_BEAM_COLOR(0xff00bbff);
|
|
const Color PROJECT_BEAM_COLOR(0xdcc35fff);
|
|
const Color TRADE_LINK_BEAM_COLOR(0x888888ff);
|
|
|
|
const Color DISABLED_BEAM_COLOR(0xff0000ff);
|
|
const Color DISABLED_BEAM_COLOR2(0xff9000ff);
|
|
|
|
vec3d strategicPosition(Object& obj) {
|
|
if(obj.isPlanet)
|
|
return obj.planetIconPosition;
|
|
if(obj.isAsteroid)
|
|
return cast<Asteroid>(obj).strategicIconPosition;
|
|
if(obj.isOddity)
|
|
return cast<Oddity>(obj).strategicIconPosition;
|
|
if(obj.isOrbital)
|
|
return cast<Orbital>(obj).strategicIconPosition;
|
|
return obj.node_position;
|
|
}
|
|
|
|
class BEAMS {
|
|
BeamNode@ heightBeam;
|
|
BeamNode@ linkBeam;
|
|
BeamNode@ projectBeam;
|
|
BeamNode@ rallyBeam;
|
|
array<BeamNode@> moveBeams;
|
|
array<BeamNode@> resourceBeams;
|
|
array<PlaneNode@> ranges;
|
|
bool primary = false;
|
|
bool isHover = false;
|
|
|
|
Object@ cacheObj;
|
|
array<OrbitalSection>@ sectionCache;
|
|
double sectCacheTime = -INFINITY;
|
|
array<const BuildingType@>@ bldCache;
|
|
double bldCacheTime = -INFINITY;
|
|
|
|
BeamNode@ makeBeam(const Color& color) {
|
|
BeamNode@ beam = BeamNode(material::MoveBeam, 0.001f, vec3d(), vec3d(), true);
|
|
beam.visible = false;
|
|
beam.color = color;
|
|
return beam;
|
|
}
|
|
|
|
void updateBeam(BeamNode@& node, const vec3d& from, const vec3d& to,
|
|
const Color& color) {
|
|
BeamNode@ check = node;
|
|
if(check is null) {
|
|
@check = makeBeam(color);
|
|
@node = check;
|
|
}
|
|
check.position = from;
|
|
check.rebuildTransform();
|
|
check.endPosition = to;
|
|
check.color = color;
|
|
check.visible = true;
|
|
}
|
|
|
|
void hideBeam(BeamNode@& node) {
|
|
BeamNode@ check = node;
|
|
if(check !is null) {
|
|
check.visible = false;
|
|
check.markForDeletion();
|
|
@node = null;
|
|
}
|
|
}
|
|
|
|
PlaneNode@ makePlane(const Color& color, const Material@ mat = material::RangeCircle) {
|
|
PlaneNode@ plane = PlaneNode(mat, 0.0);
|
|
plane.visible = false;
|
|
plane.color = color;
|
|
return plane;
|
|
}
|
|
|
|
void updatePlane(PlaneNode@& node, const vec3d& pos, double size,
|
|
const Color& color, const Material@ mat = material::RangeCircle) {
|
|
PlaneNode@ check = node;
|
|
if(check is null) {
|
|
@check = makePlane(color, mat);
|
|
@node = check;
|
|
}
|
|
check.position = pos;
|
|
check.scale = size;
|
|
check.rebuildTransform();
|
|
check.color = color;
|
|
@check.material = mat;
|
|
check.visible = true;
|
|
}
|
|
|
|
void hidePlane(PlaneNode@& node) {
|
|
PlaneNode@ check = node;
|
|
if(check !is null) {
|
|
check.visible = false;
|
|
check.markForDeletion();
|
|
@node = null;
|
|
}
|
|
}
|
|
|
|
void remove() {
|
|
if(heightBeam !is null)
|
|
heightBeam.markForDeletion();
|
|
if(linkBeam !is null)
|
|
linkBeam.markForDeletion();
|
|
if(projectBeam !is null)
|
|
projectBeam.markForDeletion();
|
|
if(rallyBeam !is null)
|
|
rallyBeam.markForDeletion();
|
|
for(uint i = 0, cnt = resourceBeams.length; i < cnt; ++i)
|
|
if(resourceBeams[i] !is null)
|
|
resourceBeams[i].markForDeletion();
|
|
for(uint i = 0, cnt = moveBeams.length; i < cnt; ++i)
|
|
if(moveBeams[i] !is null)
|
|
moveBeams[i].markForDeletion();
|
|
for(uint i = 0, cnt = ranges.length; i < cnt; ++i)
|
|
if(ranges[i] !is null)
|
|
ranges[i].markForDeletion();
|
|
}
|
|
|
|
void hideAll() {
|
|
hideBeam(heightBeam);
|
|
hideBeam(linkBeam);
|
|
hideBeam(projectBeam);
|
|
hideBeam(rallyBeam);
|
|
for(uint i = 0, cnt = resourceBeams.length; i < cnt; ++i)
|
|
hideBeam(resourceBeams[i]);
|
|
resourceBeams.length = 0;
|
|
for(uint i = 0, cnt = moveBeams.length; i < cnt; ++i)
|
|
hideBeam(moveBeams[i]);
|
|
moveBeams.length = 0;
|
|
for(uint i = 0, cnt = ranges.length; i < cnt; ++i)
|
|
hidePlane(ranges[i]);
|
|
ranges.length = 0;
|
|
}
|
|
|
|
void addBeam(array<BeamNode@>& beams, uint& index, const vec3d& from, const vec3d& to,
|
|
const Color& color) {
|
|
if(beams.length <= index) {
|
|
BeamNode@ node;
|
|
updateBeam(node, from, to, color);
|
|
beams.insertLast(node);
|
|
}
|
|
else {
|
|
updateBeam(beams[index], from, to, color);
|
|
}
|
|
index += 1;
|
|
}
|
|
|
|
void truncateBeams(array<BeamNode@>& beams, uint index) {
|
|
uint cnt = beams.length;
|
|
for(uint i = index; i < cnt; ++i)
|
|
hideBeam(beams[i]);
|
|
beams.length = index;
|
|
}
|
|
|
|
PlaneNode@ addPlane(array<PlaneNode@>& planes, uint& index, const vec3d& pos, double size,
|
|
const Color& color, const Material@ mat = material::RangeCircle) {
|
|
if(planes.length <= index) {
|
|
PlaneNode@ node;
|
|
updatePlane(node, pos, size, color, mat);
|
|
planes.insertLast(node);
|
|
index += 1;
|
|
return node;
|
|
}
|
|
else {
|
|
updatePlane(planes[index], pos, size, color, mat);
|
|
index += 1;
|
|
return planes[index-1];
|
|
}
|
|
}
|
|
|
|
void truncatePlanes(array<PlaneNode@>& planes, uint index) {
|
|
uint cnt = planes.length;
|
|
for(uint i = index; i < cnt; ++i)
|
|
hidePlane(planes[i]);
|
|
planes.length = index;
|
|
}
|
|
|
|
void setWeaponArc(PlaneNode@ node, Object@ obj, const Effector@ efftr) {
|
|
if(efftr !is null && efftr.fireArc < pi) {
|
|
vec3d offset = obj.node_rotation * efftr.turretAngle;
|
|
double rad = vec2d(offset.x, offset.z).radians();
|
|
node.minRad = rad - efftr.fireArc;
|
|
node.maxRad = rad + efftr.fireArc;
|
|
}
|
|
else {
|
|
node.minRad = -pi;
|
|
node.maxRad = +pi;
|
|
}
|
|
}
|
|
|
|
void addWeapon(array<PlaneNode@>& planes, uint& index, Object@ obj, Hook@ hook, bool showWeapons = true) {
|
|
auto@ shows = cast<ShowsRange>(hook);
|
|
if(shows !is null) {
|
|
double range = 0;
|
|
Color color;
|
|
if(shows.getShowRange(obj, range, color)) {
|
|
auto@ node = addPlane(planes, index, obj.node_position, range, color);
|
|
setWeaponArc(node, obj, null);
|
|
}
|
|
return;
|
|
}
|
|
if(!showWeapons)
|
|
return;
|
|
AddTurret@ turr;
|
|
@turr = cast<AddTurret>(hook);
|
|
if(turr is null) {
|
|
auto@ ifh = cast<IfHook>(hook);
|
|
if(ifh !is null)
|
|
@hook = ifh.hook;
|
|
auto@ rep = cast<GenericRepeatHook>(hook);
|
|
if(rep !is null)
|
|
@turr = cast<AddTurret>(rep.hook);
|
|
}
|
|
if(turr is null)
|
|
return;
|
|
|
|
auto@ node = addPlane(planes, index, obj.node_position,
|
|
turr.range, turr.def.trailStart);
|
|
setWeaponArc(node, obj, null);
|
|
}
|
|
|
|
void update(Object@ obj) {
|
|
//Deal with not displaying any object
|
|
if(obj is null) {
|
|
hideAll();
|
|
return;
|
|
}
|
|
|
|
//Update movement beams
|
|
uint movInd = 0;
|
|
if(obj.owner.controlled) {
|
|
vec3d atPos = obj.node_position;
|
|
uint ordCnt = 0;
|
|
bool wasPath = false;
|
|
if(obj.hasLeaderAI && obj.hasOrders)
|
|
ordCnt = obj.orderCount;
|
|
if(obj.hasMover) {
|
|
if(obj.isMoving) {
|
|
if(obj.hasMovePath) {
|
|
DataList@ objs = obj.getMovePath();
|
|
Object@ current;
|
|
bool wasEven = obj.inFTL;
|
|
while(receive(objs, current)) {
|
|
if(current !is null) {
|
|
vec3d dest = strategicPosition(current);
|
|
addBeam(moveBeams, movInd,
|
|
atPos, dest,
|
|
wasEven ? FTL_BEAM_COLOR : MOVE_BEAM_COLOR);
|
|
atPos = dest;
|
|
wasPath = true;
|
|
wasEven = !wasEven;
|
|
}
|
|
}
|
|
}
|
|
if(wasPath || ordCnt == 0) {
|
|
vec3d dest = obj.moveDestination;
|
|
addBeam(moveBeams, movInd,
|
|
atPos, dest,
|
|
MOVE_BEAM_COLOR);
|
|
atPos = dest;
|
|
}
|
|
}
|
|
}
|
|
if(obj.hasLeaderAI) {
|
|
for(uint i = wasPath ? 1 : 0; i < ordCnt; ++i) {
|
|
if(obj.orderHasMovement[i]) {
|
|
vec3d dest = obj.orderMoveDestination[i];
|
|
uint type = obj.orderType[i];
|
|
bool isFTL = isFTLOrder(type);
|
|
|
|
addBeam(moveBeams, movInd,
|
|
atPos, dest,
|
|
isFTL ? FTL_BEAM_COLOR : MOVE_BEAM_COLOR);
|
|
atPos = dest;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
truncateBeams(moveBeams, movInd);
|
|
|
|
//Update height beam
|
|
Region@ region = obj.region;
|
|
vec3d myPos = strategicPosition(obj);
|
|
double myY = obj.position.y;
|
|
double regionY;
|
|
if(region !is null)
|
|
regionY = region.position.y;
|
|
else
|
|
regionY = myY;
|
|
uint rangeInd = 0;
|
|
bool showWeapons = (altKey || SHOW_FIREARCS) && (!isHover || !obj.selected);
|
|
|
|
bool hasHeight = obj.region !is null && abs(myY - regionY) >= 1.0;
|
|
if(hasHeight) {
|
|
vec3d from = obj.node_position;
|
|
vec3d to = from;
|
|
to.y = regionY;
|
|
|
|
updateBeam(heightBeam, from, to,
|
|
HEIGHT_BEAM_COLOR);
|
|
}
|
|
else {
|
|
hideBeam(heightBeam);
|
|
}
|
|
|
|
//Update link beam
|
|
Object@ link;
|
|
if(obj.isAsteroid) {
|
|
Asteroid@ roid = cast<Asteroid>(obj);
|
|
@link = roid.origin;
|
|
}
|
|
else if(obj.isOddity) {
|
|
@link = cast<Oddity>(obj).getLink();
|
|
}
|
|
|
|
if(link !is null && (link.visible || link.known)) {
|
|
vec3d linkPos = strategicPosition(link);
|
|
updateBeam(linkBeam, myPos, linkPos,
|
|
LINK_BEAM_COLOR);
|
|
}
|
|
else {
|
|
hideBeam(linkBeam);
|
|
}
|
|
|
|
//Update project beam
|
|
Object@ project;
|
|
if(project !is null)
|
|
updateBeam(projectBeam, myPos, project.position, PROJECT_BEAM_COLOR);
|
|
else
|
|
hideBeam(projectBeam);
|
|
|
|
if(obj.hasConstruction && obj.owner.controlled && obj.isRallying)
|
|
updateBeam(rallyBeam, myPos, obj.rallyPosition, RALLY_BEAM_COLOR);
|
|
else
|
|
hideBeam(rallyBeam);
|
|
|
|
if(obj.isStar) {
|
|
//Update trade link beams
|
|
uint tradeInd = 0;
|
|
Region@ reg = obj.region;
|
|
if(reg !is null) {
|
|
SystemDesc@ origin = getSystem(reg);
|
|
Empire@ originPrimary = origin.object.visiblePrimaryEmpire;
|
|
for(uint i = 0, cnt = origin.adjacent.length; i < cnt; ++i) {
|
|
SystemDesc@ other = getSystem(origin.adjacent[i]);
|
|
if(playerEmpire !is null && playerEmpire.valid && other.object.ExploredMask & playerEmpire.visionMask == 0)
|
|
continue;
|
|
|
|
Empire@ otherPrimary = other.object.visiblePrimaryEmpire;
|
|
|
|
Color col = TRADE_LINK_BEAM_COLOR;
|
|
if(originPrimary !is null && originPrimary is otherPrimary && otherPrimary.valid)
|
|
col = originPrimary.color;
|
|
col.a = 0x80;
|
|
|
|
vec3d offset = origin.position - other.position;
|
|
offset.y = 0.0;
|
|
offset.normalize();
|
|
|
|
addBeam(resourceBeams, tradeInd, origin.position - offset * origin.radius,
|
|
other.position + offset * other.radius, col);
|
|
}
|
|
}
|
|
truncateBeams(resourceBeams, tradeInd);
|
|
}
|
|
else {
|
|
//Update resource beams
|
|
uint resInd = 0;
|
|
if(obj.hasResources) {
|
|
array<Resource> resources;
|
|
resources.syncFrom(obj.getNativeResources());
|
|
|
|
uint nativeCnt = obj.nativeResourceCount;
|
|
|
|
for(uint i = 0; i < resources.length; ++i) {
|
|
auto@ res = resources[i];
|
|
if(res.origin !is obj)
|
|
continue;
|
|
|
|
Object@ dest = res.exportedTo;
|
|
if(dest is null)
|
|
@dest = obj.nativeResourceDestination[i];
|
|
if(dest is null || dest is obj)
|
|
continue;
|
|
if(dest is hovered || dest.selected)
|
|
continue;
|
|
|
|
vec3d theirPos = strategicPosition(dest);
|
|
|
|
Color color = EXPORT_BEAM_COLOR;
|
|
if(obj.owner !is playerEmpire || dest.owner !is playerEmpire)
|
|
color = QUEUED_EXPORT_BEAM_COLOR;
|
|
else if(!res.usable)
|
|
color = GlowBeamColor;
|
|
|
|
addBeam(resourceBeams, resInd,
|
|
myPos, theirPos, color);
|
|
}
|
|
|
|
if(obj.owner.controlled) {
|
|
resources.syncFrom(obj.getAvailableResources());
|
|
for(uint i = 0; i < resources.length; ++i) {
|
|
auto@ res = resources[i];
|
|
Object@ origin = res.origin;
|
|
if(origin is null || origin is obj)
|
|
continue;
|
|
|
|
vec3d theirPos = strategicPosition(origin);
|
|
|
|
Color color = IMPORT_BEAM_COLOR;
|
|
if(!res.usable)
|
|
color = GlowBeamColor;
|
|
|
|
addBeam(resourceBeams, resInd,
|
|
theirPos, myPos,
|
|
color);
|
|
|
|
if(showWeapons) {
|
|
auto@ type = res.type;
|
|
if(type !is null) {
|
|
for(uint j = 0, jcnt = type.hooks.length; j < jcnt; ++j)
|
|
addWeapon(ranges, rangeInd, obj, cast<Hook>(type.hooks[j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(obj.queuedImportCount > 0) {
|
|
resources.syncFrom(obj.getQueuedImports());
|
|
for(uint i = 0; i < resources.length; ++i) {
|
|
auto@ res = resources[i];
|
|
Object@ origin = res.origin;
|
|
if(origin is null || origin is obj)
|
|
continue;
|
|
|
|
vec3d theirPos = strategicPosition(origin);
|
|
|
|
addBeam(resourceBeams, resInd,
|
|
theirPos, myPos,
|
|
QUEUED_IMPORT_BEAM_COLOR);
|
|
}
|
|
}
|
|
}
|
|
truncateBeams(resourceBeams, resInd);
|
|
}
|
|
|
|
//Weapon ranges
|
|
if(!isHover || !obj.selected) {
|
|
if(showWeapons && obj.isShip) {
|
|
Ship@ ship = cast<Ship>(obj);
|
|
auto@ bp = ship.blueprint;
|
|
if(bp is null)
|
|
return;
|
|
auto@ dsg = bp.design;
|
|
if(dsg is null)
|
|
return;
|
|
uint resInd = 0;
|
|
for(uint i = 0, cnt = dsg.subsystemCount; i < cnt; ++i) {
|
|
auto@ ss = dsg.subsystems[i];
|
|
if(ss.has(SV_Range)) {
|
|
auto@ node = addPlane(ranges, rangeInd, obj.node_position,
|
|
ss[SV_Range], ss.type.typeColor);
|
|
|
|
if(ss.effectorCount > 0) {
|
|
auto@ efftr = ss.effectors[0];
|
|
setWeaponArc(node, obj, ss.effectors[0]);
|
|
}
|
|
else {
|
|
setWeaponArc(node, obj, null);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
if(obj.isOrbital) {
|
|
auto@ type = getOrbitalModule("FlingCore");
|
|
if(type !is null && cast<Orbital>(obj).coreModule == type.id) {
|
|
addPlane(ranges, rangeInd, obj.node_position,
|
|
FLING_BEACON_RANGE, Color(0x2bff0cff));
|
|
}
|
|
if(cacheObj !is obj || sectionCache is null || sectCacheTime < frameTime - 3.0) {
|
|
if(sectionCache is null)
|
|
@sectionCache = array<OrbitalSection>();
|
|
sectionCache.syncFrom(cast<Orbital>(obj).getSections());
|
|
sectCacheTime = frameTime;
|
|
@cacheObj = obj;
|
|
}
|
|
for(uint i = 0, cnt = sectionCache.length; i < cnt; ++i) {
|
|
auto@ sect = sectionCache[i];
|
|
for(uint j = 0, jcnt = sect.type.hooks.length; j < jcnt; ++j)
|
|
addWeapon(ranges, rangeInd, obj, cast<Hook>(sect.type.hooks[j]), showWeapons);
|
|
}
|
|
}
|
|
if(obj.isShip) {
|
|
Ship@ ship = cast<Ship>(obj);
|
|
auto@ bp = ship.blueprint;
|
|
if(bp !is null) {
|
|
auto@ dsg = bp.design;
|
|
if(dsg !is null) {
|
|
if(dsg.hasTag(ST_Slipstream)) {
|
|
addPlane(ranges, rangeInd, obj.node_position,
|
|
dsg.average(SV_SlipstreamOptimalDistance), Color(0x67a7ad));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(showWeapons && obj.isPlanet && obj.getBuildingCount() > 0) {
|
|
if(cacheObj !is obj || bldCache is null || bldCacheTime < frameTime - 2.9) {
|
|
if(bldCache is null)
|
|
@bldCache = array<const BuildingType@>();
|
|
bldCacheTime = frameTime;
|
|
@cacheObj = obj;
|
|
uint cnt = obj.getBuildingCount();
|
|
bldCache.length = 0;
|
|
bldCache.reserve(cnt);
|
|
for(uint i = 0, cnt = obj.getBuildingCount(); i < cnt; ++i) {
|
|
auto@ type = getBuildingType(obj.buildingType[i]);
|
|
if(type !is null)
|
|
bldCache.insertLast(type);
|
|
}
|
|
}
|
|
for(uint i = 0, cnt = bldCache.length; i < cnt; ++i) {
|
|
auto@ type = bldCache[i];
|
|
for(uint j = 0, jcnt = type.hooks.length; j < jcnt; ++j)
|
|
addWeapon(ranges, rangeInd, obj, cast<Hook>(type.hooks[j]), showWeapons);
|
|
}
|
|
}
|
|
}
|
|
truncatePlanes(ranges, rangeInd);
|
|
}
|
|
};
|
|
|
|
array<BEAMS@> selectedBeams;
|
|
BEAMS hoverBeams;
|
|
|
|
void updateHoverBeams() {
|
|
hoverBeams.update(hovered);
|
|
}
|
|
|
|
void updateBeams() {
|
|
uint oldCnt = selectedBeams.length;
|
|
uint cnt = selection.length;
|
|
|
|
for(uint i = cnt; i < oldCnt; ++i)
|
|
selectedBeams[i].remove();
|
|
|
|
selectedBeams.length = cnt;
|
|
for(uint i = 0; i < cnt; ++i) {
|
|
if(selectedBeams[i] is null)
|
|
@selectedBeams[i] = BEAMS();
|
|
selectedBeams[i].primary = i == 0;
|
|
selectedBeams[i].update(selection[i]);
|
|
}
|
|
}
|
|
|
|
Color GlowBeamColor;
|
|
void tick(double time) {
|
|
float pct = abs((frameTime % 1.0) - 0.5f) * 2.f;
|
|
GlowBeamColor = DISABLED_BEAM_COLOR.interpolate(DISABLED_BEAM_COLOR2, pct);
|
|
|
|
updateBeams();
|
|
updateHoverBeams();
|
|
for(int i = selection.length - 1; i >= 0; --i) {
|
|
if(!selection[i].valid)
|
|
selection.removeAt(i);
|
|
}
|
|
}
|
|
|
|
void render(double time) {
|
|
if(debugCursor) {
|
|
vec3d mpos;
|
|
if(getElevationIntersect(activeCamera.screenToRay(mousePos), mpos)) {
|
|
double size = activeCamera.distance / 80.0;
|
|
renderBillboard(material::PlanetImage, mpos, size);
|
|
mpos.y = getElevation(mpos.x, mpos.z);
|
|
renderBillboard(material::SmallLogo, mpos, size);
|
|
}
|
|
}
|
|
}
|
|
|
|
void save(SaveFile& file) {
|
|
for(uint i = 0; i < 9; ++i) {
|
|
uint cnt = groups[i].length;
|
|
file << cnt;
|
|
for(uint j = 0; j < cnt; ++j)
|
|
file << groups[i][j];
|
|
}
|
|
}
|
|
|
|
void load(SaveFile& file) {
|
|
for(uint i = 0; i < 9; ++i) {
|
|
uint cnt = 0;
|
|
file >> cnt;
|
|
groups[i].length = cnt;
|
|
for(uint j = 0; j < cnt; ++j)
|
|
file >> groups[i][j];
|
|
}
|
|
}
|