private void Refresh()
{
if (items == null)
{
items = new PooledList<ShipStatsEntry, KeyValuePair<string, string>>(content, statsEntryPrefab);
}
if (!PlayerShip.LocalPlayer)
{
items.Clear();
return;
}
var ship = PlayerShip.LocalPlayer.Ship;
var stats = ship.CurrentStats;
var hp = ship.GetComponent<Hitpoints>();
var entries = new Dictionary<string, string>();
entries.Add("DPS", ship.EstimateDps().ToString("F2"));
entries.Add("Max speed", stats.MaxSpeed.ToString("F2") +"m/s");
entries.Add("Agility", stats.MaxTurnSpeed.ToString("F2") + "deg/s");
entries.Add("Armor", hp.GetMaxArmor().ToString());
entries.Add("Shield", hp.GetMaxShields().ToString());
entries.Add("Mass", (stats.Mass * 0.001f).ToString("F2") + "t");
if (items == null)
{
items = new PooledList<ShipStatsEntry, KeyValuePair<string, string>>(content, statsEntryPrefab);
}
items.Refresh(entries, (i, item, entry) => item.SetText(entry.Key, entry.Value));
}
void CollectPreviewProperties(PooledList <PreviewProperty> perMaterialPreviewProperties)
{
using (CollectPreviewPropertiesMarker.Auto())
using (var tempCollectNodes = PooledHashSet <AbstractMaterialNode> .Get())
using (var tempPreviewProps = PooledList <PreviewProperty> .Get())
{
// we only collect properties from nodes upstream of something we want to draw
// TODO: we could go a step farther and only collect properties from nodes we know have changed their value
// but that's not something we currently track...
PropagateNodes(m_NodesToDraw, PropagationDirection.Upstream, tempCollectNodes);
foreach (var propNode in tempCollectNodes)
{
propNode.CollectPreviewMaterialProperties(tempPreviewProps);
}
foreach (var prop in m_Graph.properties)
{
tempPreviewProps.Add(prop.GetPreviewMaterialProperty());
}
foreach (var previewProperty in tempPreviewProps)
{
previewProperty.SetValueOnMaterialPropertyBlock(m_SharedPreviewPropertyBlock);
// virtual texture assignments must be pushed to the materials themselves (MaterialPropertyBlocks not supported)
if ((previewProperty.propType == PropertyType.VirtualTexture) &&
(previewProperty.vtProperty?.value?.layers != null))
{
perMaterialPreviewProperties.Add(previewProperty);
}
}
}
}
private IEnumerator SortRoutine()
{
while (true)
{
using (PooledList <Transform> children = PooledList <Transform> .Create())
{
if (children.Capacity < SortGroup.childCount)
{
children.Capacity = SortGroup.childCount;
}
for (int i = 0; i < SortGroup.childCount; ++i)
{
children.Add(SortGroup.GetChild(i));
}
children.Sort(s_HeightSorter);
for (int i = 0; i < children.Count; ++i)
{
children[i].SetSiblingIndex(i);
}
if (Controller.DraggingObject != null && Controller.DraggingObject.transform.parent == SortGroup)
{
Controller.DraggingObject.transform.SetAsLastSibling();
}
}
yield return(0.05f);
}
}
public void GlobalSetup()
{
list = CreateList(N);
pooled = CreatePooled(N);
containedList = list[list.Count / 2];
containedPooled = pooled[pooled.Count / 2];
}
public void BasicInsert(T[] items, T item, int index, int repeat)
{
using (var list = new PooledList <T>(items))
{
for (int i = 0; i < repeat; i++)
{
list.Insert(index, item);
}
Assert.True(list.Contains(item)); //"Expect it to contain the item."
Assert.Equal(list.Count, items.Length + repeat); //"Expect to be the same."
for (int i = 0; i < index; i++)
{
Assert.Equal(list[i], items[i]); //"Expect to be the same."
}
for (int i = index; i < index + repeat; i++)
{
Assert.Equal(list[i], item); //"Expect to be the same."
}
for (int i = index + repeat; i < list.Count; i++)
{
Assert.Equal(list[i], items[i - repeat]); //"Expect to be the same."
}
}
}
void CollectPreviewProperties()
{
using (CollectPreviewPropertiesMarker.Auto())
using (var tempCollectNodes = PooledHashSet <AbstractMaterialNode> .Get())
using (var tempPreviewProps = PooledList <PreviewProperty> .Get())
{
// we only collect properties from nodes upstream of something we want to draw
// TODO: we could go a step farther and only collect properties from nodes we know have changed their value
// but that's not something we currently track...
PropagateNodes(m_NodesToDraw, PropagationDirection.Upstream, tempCollectNodes);
foreach (var propNode in tempCollectNodes)
{
propNode.CollectPreviewMaterialProperties(tempPreviewProps);
}
foreach (var prop in m_Graph.properties)
{
tempPreviewProps.Add(prop.GetPreviewMaterialProperty());
}
foreach (var previewProperty in tempPreviewProps)
{
previewProperty.SetValueOnMaterialPropertyBlock(m_SharedPreviewPropertyBlock);
}
}
}
public void Reverse_int_int(int listLength, int index, int count)
{
PooledList <T> list = GenericListFactory(listLength);
PooledList <T> listBefore = list.ToPooledList();
list.Reverse(index, count);
for (int i = 0; i < index; i++)
{
Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same."
}
int j = 0;
for (int i = index; i < index + count; i++)
{
Assert.Equal(list[i], listBefore[index + count - (j + 1)]); //"Expect them to be the same."
j++;
}
for (int i = index + count; i < listBefore.Count; i++)
{
Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same."
}
list.Dispose();
listBefore.Dispose();
}
public static void ToStream(Voxel[] voxels, Stream stream)
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII, true))
{
var encoded = new PooledList <long>();
var currentVoxel = voxels[0];
ushort currentLength = 1;
for (int i = 1; i < voxels.Length; i++)
{
if (voxels[i] == currentVoxel)
{
currentLength++;
}
else
{
writer.Write(currentLength);
writer.Write(currentVoxel.Data);
currentVoxel = voxels[i];
currentLength = 1;
}
}
writer.Write(currentLength);
writer.Write(currentVoxel.Data);
}
}
public EmbedMenu(ref EmbedMenuAct ExecutedEMAct, ref EmbedMenu <UserT, ChannelT> PrevEM, string title, string desc)
{
InitAct = ExecutedEMAct.Act;
EMHistory = PrevEM.EMHistory;
Title = title;
Desc = desc;
Acts = PrevEM.Acts;
CurrentEMIndex = unchecked (++PrevEM.CurrentEMIndex);
//Page defaults
CurrentPageNumber = 0;
MaxElemsPerPage = 5;
Pages = EMHelpers.DivideAndRoundUpFast(Acts.Count, MaxElemsPerPage);
//User creds
User = PrevEM.User;
Channel = PrevEM.Channel;
Unsafe.SkipInit(out CurrentMsg);
}
private static bool ProcessTags(ref AttributeEnumerationState state, KeyValuePair <string, string> attribute)
{
string key = attribute.Key;
string strVal = attribute.Value;
if (strVal != null)
{
if (RemoteEndpointServiceNameKeyResolutionDictionary.TryGetValue(key, out int priority) &&
(state.RemoteEndpointServiceName == null || priority < state.RemoteEndpointServiceNamePriority))
{
state.RemoteEndpointServiceName = strVal;
state.RemoteEndpointServiceNamePriority = priority;
}
else if (key == Resource.ServiceNameKey)
{
state.ServiceName = strVal;
}
else if (key == Resource.ServiceNamespaceKey)
{
state.ServiceNamespace = strVal;
}
else
{
PooledList <KeyValuePair <string, string> > .Add(ref state.Tags, new KeyValuePair <string, string>(key, strVal));
}
}
else
{
PooledList <KeyValuePair <string, string> > .Add(ref state.Tags, new KeyValuePair <string, string>(key, strVal));
}
return(true);
}
void ForeachConnectedNode(AbstractMaterialNode node, PropagationDirection dir, Action <AbstractMaterialNode> action)
{
using (var tempEdges = PooledList <IEdge> .Get())
using (var tempSlots = PooledList <MaterialSlot> .Get())
{
// Loop through all nodes that the node feeds into.
if (dir == PropagationDirection.Downstream)
{
node.GetOutputSlots(tempSlots);
}
else
{
node.GetInputSlots(tempSlots);
}
foreach (var slot in tempSlots)
{
// get the edges out of each slot
tempEdges.Clear(); // and here we serialize another list, ouch!
m_Graph.GetEdges(slot.slotReference, tempEdges);
foreach (var edge in tempEdges)
{
// We look at each node we feed into.
var connectedSlot = (dir == PropagationDirection.Downstream) ? edge.inputSlot : edge.outputSlot;
var connectedNode = connectedSlot.node;
action(connectedNode);
}
}
}
}
private HashSet <ushort> DnaToUsedNodes(BitArray dna)
{
using (var mstNodes = new PooledList <int>(dna.Length + TargetNodes.Count))
using (var mst = new MinimalSpanningTree(mstNodes, Distances))
{
for (var i = 0; i < dna.Length; i++)
{
if (dna[i])
{
mstNodes.Add(i);
}
}
var searchSpaceNodeCount = mstNodes.Count;
for (var i = 0; i < TargetNodes.Count; i++)
{
mstNodes.Add(TargetNodes[i].DistancesIndex);
}
var spanningEdges = _orderedEdges is null
? mst.Span(StartNode.DistancesIndex)
: mst.Span(_orderedEdges);
return(GetSkillNodeIds(mstNodes, searchSpaceNodeCount, spanningEdges));
}
}
internal EmbedMenu(EmbedMenuDel initAct, UserT user, ChannelT channel, ref PooledList <EmbedMenu <UserT, ChannelT> > emHistory, ref PooledList <EmbedMenuAct> acts)
{
InitAct = initAct;
User = user;
Channel = channel;
EMHistory = emHistory;
Acts = acts;
CurrentEMIndex = 0;
//Page defaults
CurrentPageNumber = 0;
MaxElemsPerPage = 5;
Pages = EMHelpers.DivideAndRoundUpFast(Acts.Count, MaxElemsPerPage);
Unsafe.SkipInit(out Title);
Unsafe.SkipInit(out Desc);
Unsafe.SkipInit(out CurrentMsg);
}
public bool ForEach(KeyValuePair <string, object> activityTag)
{
if (activityTag.Value == null)
{
return(true);
}
string key = activityTag.Key;
if (activityTag.Value is string strVal)
{
PeerServiceResolver.InspectTag(ref this, key, strVal);
if (key == SpanAttributeConstants.StatusCodeKey)
{
if (strVal == "Error")
{
PooledList <KeyValuePair <string, object> > .Add(ref this.Tags, new KeyValuePair <string, object>("error", "true"));
}
else if (strVal == "Unset")
{
// Unset Status is not sent: https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/sdk_exporters/zipkin.md#status
return(true);
}
}
}
else if (activityTag.Value is int intVal && activityTag.Key == SemanticConventions.AttributeNetPeerPort)
{
PeerServiceResolver.InspectTag(ref this, key, intVal);
}
PooledList <KeyValuePair <string, object> > .Add(ref this.Tags, activityTag);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="RoutedEvent"/> class.
/// </summary>
/// <param name="e">The routed event to be raised.</param>
public EventRoute(RoutedEvent e)
{
e = e ?? throw new ArgumentNullException(nameof(e));
_event = e;
_route = null;
}
internal SectionMeshData(PooledList <int> simpleVertexData,
PooledList <float> complexVertexPositions, PooledList <int> complexVertexData,
PooledList <uint> complexIndices,
PooledList <int> varyingHeightVertexData, PooledList <uint> varyingHeightIndices,
PooledList <int> crossPlantVertexData,
PooledList <int> cropPlantVertexData,
PooledList <int> opaqueLiquidVertexData, PooledList <uint> opaqueLiquidIndices,
PooledList <int> transparentLiquidVertexData, PooledList <uint> transparentLiquidIndices)
{
this.simpleVertexData = simpleVertexData;
this.complexVertexPositions = complexVertexPositions;
this.complexVertexData = complexVertexData;
this.complexIndices = complexIndices;
this.varyingHeightVertexData = varyingHeightVertexData;
this.varyingHeightIndices = varyingHeightIndices;
this.crossPlantVertexData = crossPlantVertexData;
this.cropPlantVertexData = cropPlantVertexData;
this.opaqueLiquidVertexData = opaqueLiquidVertexData;
this.opaqueLiquidIndices = opaqueLiquidIndices;
this.transparentLiquidVertexData = transparentLiquidVertexData;
this.transparentLiquidIndices = transparentLiquidIndices;
}
public void PooledAddRange_String_CapacityIncrease_Array()
{
var pooled = new PooledList <string>();
for (int j = 0; j < addLoops; j++)
{
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
}
pooled.Dispose();
}
public void GlobalSetup()
{
listInt = CreateList(N);
listString = listInt.ConvertAll(i => i.ToString());
pooledInt = new PooledList <int>(listInt);
pooledString = pooledInt.ConvertAll(i => i.ToString());
}
public void PooledAddRange_Int_CapacityIncrease_Enumerable()
{
var pooled = new PooledList <string>();
var enumerable = (IEnumerable <string>)sampleSet;
for (int j = 0; j < addLoops; j++)
{
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
pooled.AddRange(enumerable);
}
pooled.Dispose();
}
private void Refresh()
{
if (statsLines == null)
{
statsLines = new PooledList<ShipStatsEntry, KeyValuePair<string, string>>(statsRoot.transform, statsPrefab);
}
if (itemType)
{
nameLabel.text = itemType.DisplayName;
icon.sprite = itemType.Icon;
icon.gameObject.SetActive(true);
descriptionLabel.text = itemType.Description;
var stats = new List<KeyValuePair<string, string>>();
var player = SpaceTraderConfig.LocalPlayer;
var station = player.Ship.Moorable.DockedAtStation;
var market = SpaceTraderConfig.Market;
var baseVal = Market.FormatCurrency(itemType.BaseValue);
stats.Add(new KeyValuePair<string, string>("Base Value", baseVal));
if (station)
{
int price;
string priceType;
if (itemOwnedByPlayer)
{
price = market.GetSellingItemPrice(itemType, station);
priceType= "Sells For";
}
else
{
price = market.GetBuyingItemPrice(itemType, station);
priceType = "Price";
}
stats.Add(new KeyValuePair<string, string>(priceType, Market.FormatCurrency(price)));
}
stats.AddRange(itemType.GetDisplayedStats(itemOwnedByPlayer? player.Ship : null));
statsLines.Refresh(stats, (i, statsLine, statsEntry) =>
statsLine.SetText(statsEntry.Key, statsEntry.Value));
}
else
{
nameLabel.text = "No item selected";
icon.gameObject.SetActive(false);
descriptionLabel.text = null;
statsLines.Clear();
}
statsRoot.Elements = statsLines.Select(l => (RectTransform) l.transform);
}
protected virtual PooledList <T> GenericListFactory(int count)
{
IEnumerable <T> toCreateFrom = CreateEnumerable(EnumerableType.List, null, count, 0, 0);
var list = new PooledList <T>(toCreateFrom);
RegisterForDispose(list);
return(list);
}
public void Constructor_Default()
{
PooledList <T> list = new PooledList <T>();
Assert.Equal(0, list.Capacity); //"Expected capacity of list to be the same as given."
Assert.Empty(list); //"Do not expect anything to be in the list."
Assert.False(((IList <T>)list).IsReadOnly); //"List should not be readonly"
}
public void TerribleBugWhenAppendingString()
{
var expected = "longer than the capacity";
var builder = new PooledList <char>(1);
builder.AddRange(expected.AsSpan());
Assert.Equal(expected, builder.AsEnumerable());
}
public void NoSizeToCapacityItemsSet()
{
var list = new PooledList <T>(13, false);
var value = CreateT(42);
Assert.Throws <ArgumentOutOfRangeException>(() => list[12] = value);
list.Dispose();
}
public void PooledIterSetup()
{
pooledLists = new PooledList <int> [5000];
for (int i = 0; i < 5000; i++)
{
pooledLists[i] = new PooledList <int>(list);
}
}
public void SizeToCapacityCapacityCount()
{
var list = new PooledList <T>(13, true);
Assert.InRange(list.Capacity, 13, list.Capacity);
Assert.Equal(13, list.Count);
list.Dispose();
}
public void InsertRangeIEnumerable(T[] itemsX, T[] itemsY, int index, int repeat, Func <T[], IEnumerable <T> > constructIEnumerable)
{
PooledList <T> list = new PooledList <T>(constructIEnumerable(itemsX));
for (int i = 0; i < repeat; i++)
{
list.InsertRange(index, constructIEnumerable(itemsY));
}
foreach (T item in itemsY)
{
Assert.True(list.Contains(item)); //"Should contain the item."
}
Assert.Equal(list.Count, itemsX.Length + (itemsY.Length * repeat)); //"Should have the same result."
for (int i = 0; i < index; i++)
{
Assert.Equal(list[i], itemsX[i]); //"Should have the same result."
}
for (int i = index; i < index + (itemsY.Length * repeat); i++)
{
Assert.Equal(list[i], itemsY[(i - index) % itemsY.Length]); //"Should have the same result."
}
for (int i = index + (itemsY.Length * repeat); i < list.Count; i++)
{
Assert.Equal(list[i], itemsX[i - (itemsY.Length * repeat)]); //"Should have the same result."
}
//InsertRange into itself
list.Dispose();
list = new PooledList <T>(constructIEnumerable(itemsX));
list.InsertRange(index, list);
foreach (T item in itemsX)
{
Assert.True(list.Contains(item)); //"Should contain the item."
}
Assert.Equal(list.Count, itemsX.Length + itemsX.Length); //"Should have the same result."
for (int i = 0; i < index; i++)
{
Assert.Equal(list[i], itemsX[i]); //"Should have the same result."
}
for (int i = index; i < index + itemsX.Length; i++)
{
Assert.Equal(list[i], itemsX[(i - index) % itemsX.Length]); //"Should have the same result."
}
for (int i = index + (itemsX.Length); i < list.Count; i++)
{
Assert.Equal(list[i], itemsX[i - (itemsX.Length)]); //"Should have the same result."
}
list.Dispose();
}
public void PooledAddRangeIEnumerable()
{
for (int i = 0; i < 5000; i++)
{
var emptyList = new PooledList <int>();
emptyList.AddRange(IntEnumerable());
emptyList.Dispose();
}
}
public void PooledAddRangeICollection()
{
for (int i = 0; i < 5000; i++)
{
var emptyList = new PooledList <int>();
emptyList.AddRange(list);
emptyList.Dispose();
}
}
public void CopyTo_ArgumentValidity(int count)
{
if (count > 0)
{
PooledList <T> list = GenericListFactory(count);
AssertExtensions.Throws <ArgumentException>(null, () => list.CopyTo(new T[0]));
list.Dispose();
}
}
public void GlobalSetup()
{
int samples = GetSampleLength();
sampleSet = new int[samples];
for (int i = 0; i < samples; i++)
{
sampleSet[i] = i;
}
addLoops = LARGE_SAMPLE_LENGTH / samples;
// create lists big enough to hold 17 copies of the sample set
startingCapacity = 17 * samples * addLoops;
list = new List <int>(startingCapacity);
pooled = new PooledList <int>(startingCapacity);
for (int j = 0; j < addLoops; j++)
{
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
list.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
pooled.AddRange(sampleSet);
}
}
public void Reverse_InvalidParameters(int listLength)
{
if (listLength % 2 != 0)
{
listLength++;
}
PooledList <T> list = GenericListFactory(listLength);
(int, int)[] InvalidParameters = new[]
public void Refresh(PooledList<QuestListItem, Quest> itemsList)
{
EmptyMessage.gameObject.SetActive(itemsList.Count == 0);
//status of quests can change independent of which quests are displayed
foreach (var item in itemsList)
{
item.UpdateStatus();
}
}
private void Update()
{
if (notifications == null)
{
notifications = new PooledList<MessagePanelItem, IPlayerNotification>(messageContent, messagePrefab);
}
var items = PlayerNotifications.GetNotifications(notificationCount, notificationCategory)
.Where(n => n.Created > Time.time - maxAge);
notifications.Refresh(items, (i, item, data) =>
item.Assign(data.Text));
}
private void Update()
{
var player = PlayerShip.LocalPlayer;
if (modules == null)
{
modules = new PooledList<ShipModuleController, HardpointModule>(modulesRoot, moduleTemplate);
}
if (!player)
{
modules.Clear();
return;
}
modules.Refresh(player.Ship.ModuleLoadout, (i, module, slot) =>
module.Assign(player.Ship, i, i == highlightedIndex));
}
public void Refresh()
{
if (questList == null)
{
questList = new PooledList<QuestListItem, Quest>(availableQuests.ItemsRoot, itemPrefab);
}
if (acceptedQuestList == null)
{
acceptedQuestList = new PooledList<QuestListItem, Quest>(acceptedQuests.ItemsRoot, itemPrefab);
}
var player = SpaceTraderConfig.LocalPlayer;
if (player)
{
var station = player.Moorable.DockedAtStation;
var myQuests = SpaceTraderConfig.QuestBoard.QuestsForPlayer(player);
var questsNotAccepted = SpaceTraderConfig.QuestBoard.QuestsAtStation(station)
.Except(myQuests);
availableQuests.SetActive(station);
if (station)
{
questList.Refresh(questsNotAccepted, (index, listItem, quest) =>
listItem.Assign(quest));
}
else
{
questList.Clear();
}
acceptedQuestList.Refresh(myQuests, (index, listItem, quest) =>
listItem.Assign(quest));
}
else
{
questList.Clear();
acceptedQuestList.Clear();
}
availableQuests.Refresh(questList);
acceptedQuests.Refresh(acceptedQuestList);
}
public void Update()
{
var player = PlayerShip.LocalPlayer;
if (items == null)
{
items = new PooledList<FleetListItem, Ship>(content, itemPrefab);
}
Fleet playerFleet;
if (!player
|| !player.Ship
|| !(playerFleet = SpaceTraderConfig.FleetManager.GetFleetOf(player.Ship)))
{
items.Clear();
}
else
{
var ships = playerFleet.Members.ToList();
ships.Remove(player.Ship);
items.Refresh(ships, (i, item, ship) => item.Assign(ship, bracketManager.FleetMemberColor));
}
}
void LateUpdate()
{
if (brackets == null)
{
brackets = new PooledList<Bracket, Targetable>(transform, bracket);
}
UpdateShipBrackets();
var spaceCam = FollowCamera.Current;
if (spaceCam && spaceCam.isActiveAndEnabled)
{
CheckSpaceClicks(spaceCam);
}
}
private void Update()
{
IEnumerable<CrewMember> crew = null;
Ship playerShip = PlayerShip.LocalPlayer ? PlayerShip.LocalPlayer.Ship : null;
if (playerShip)
{
if (targetCrew == TargetCrew.Station)
{
var station = PlayerShip.LocalPlayer.Moorable.DockedAtStation;
if (station)
{
crew = station.AvailableCrew;
}
}
else
{
switch (forAssignment)
{
case CrewAssignment.Captain:
crew = playerShip.GetCaptain().AsOptionalObject();
break;
default:
crew = playerShip.GetPassengers();
break;
}
}
}
if (crewItems == null)
{
crewItems = new PooledList<CrewListItem, CrewMember>(contentArea, itemPrefab);
}
if (crew != null && crew.Any())
{
CrewListItem.BuySellMode buySellMode;
if (playerShip.Moorable.DockedAtStation)
{
if (targetCrew == TargetCrew.Player)
{
buySellMode = CrewListItem.BuySellMode.Sellable;
}
else
{
buySellMode = CrewListItem.BuySellMode.Buyable;
}
}
else
{
buySellMode = CrewListItem.BuySellMode.ReadOnly;
}
crewItems.Refresh(crew, (i, existingItem, newCrewMember) =>
existingItem.Assign(newCrewMember, buySellMode));
emptyLabel.gameObject.SetActive(false);
}
else
{
crewItems.Clear();
emptyLabel.gameObject.SetActive(true);
}
}
void LateUpdate()
{
if (markers == null)
{
markers = new PooledList<PredictorMarker, Vector3>(transform, markerPrefab);
}
var player = PlayerShip.LocalPlayer;
var camera = FollowCamera.Current.Camera;
Ship playerShip;
if (!player
|| !(playerShip = player.Ship)
|| !player.Ship.Target
|| player.Ship.Target.TargetSpace != TargetSpace.Local
|| !camera)
{
markers.Clear();
return;
}
var loadout = playerShip.ModuleLoadout;
var modCount = loadout.SlotCount;
var newMarkerPositions = new List<Vector3>(modCount);
//var markerItems = new List<HardpointModule>();
var playerTargetable = playerShip.Targetable;
/* one marker per active hardpoint module which returns true for
IsPredictable. we get the prediction points from the module's
behaviour here too */
for (int moduleIndex = 0; moduleIndex < modCount; ++moduleIndex)
{
var module = loadout.GetSlot(moduleIndex);
if (!module.ModuleType)
{
//empty slot
continue;
}
var behavior = module.ModuleType.Behaviour;
var predictPoint = behavior.PredictTarget(playerShip, moduleIndex, playerShip.Target);
if (predictPoint.HasValue)
{
if (predictPoint.HasValue && predictPoint.Value.z >= 0)
{
newMarkerPositions.Add(predictPoint.Value);
}
}
}
var targetOrigin = player.Ship.Target.transform.position;
float maxDistSqr = 0;
for (int pos = 0; pos < newMarkerPositions.Count; ++pos)
{
float distSqr = (targetOrigin - newMarkerPositions[pos]).sqrMagnitude;
maxDistSqr = Mathf.Max(maxDistSqr, distSqr);
}
if (maxDistSqr < MIN_SPEED)
{
markers.Clear();
}
else
{
var predictorColor = brackets.GetBracketColor(playerTargetable, playerShip.Target);
markers.Refresh(newMarkerPositions, (i, marker, position) =>
{
//PredictTarget returns world pos
var screenPos = camera.WorldToScreenPoint(position);
marker.transform.position = screenPos;
marker.Color = predictorColor;
});
}
}
