private async Task <List <OpenTrade> > ConvertToOpenTrades(IAsyncEnumerable <RawCsvData> readData)
{
var result = new List <OpenTrade>(50);
await foreach (var entry in readData)
{
var trade = new OpenTrade
(
accountId: _curAccount.CurrentAccount.Id,
datetime: entry.Time,
type: entry.Type.ParseToSideEnum(),
firstCurrency: entry.Pair.GetCurrencyEnumPair().Item1,
secondCurrency: entry.Pair.GetCurrencyEnumPair().Item2,
price: entry.Price,
amount: entry.Vol,
sum: entry.Cost,
feeCurency: Currency.USD,
fee: entry.Fee
);
result.Add(trade);
}
return(result);
}
void OnItemAddedToContainer(ItemContainer container, Item item)
{
if (container.playerOwner is BasePlayer)
{
OnlinePlayer onlinePlayer;
if (onlinePlayers.TryGetValue(container.playerOwner, out onlinePlayer) && onlinePlayer.Trade != null)
{
OpenTrade t = onlinePlayers [container.playerOwner].Trade;
if (!t.complete)
{
t.ResetAcceptance();
if (t.IsValid())
{
ShowTrades(t, "Trade: Pending");
}
else
{
TradeCloseBoxes(t);
}
}
}
}
}
void OnItemRemovedFromContainer(ItemContainer container, Item item)
{
if (container.playerOwner is BasePlayer)
{
OnlinePlayer onlinePlayer;
if (onlinePlayers.TryGetValue(container.playerOwner, out onlinePlayer) && onlinePlayer.Trade != null)
{
OpenTrade t = onlinePlayers[container.playerOwner].Trade;
if (!t.complete)
{
t.sourceAccept = false;
t.targetAccept = false;
if (t.IsValid())
{
ShowTrades(t, "Trade: Pending");
}
else
{
TradeCloseBoxes(t);
}
}
}
}
}
void TradeReply(OpenTrade trade, string msg, string msg2 = null)
{
if (msg2 == null)
{
msg2 = msg;
}
SendReply(trade.targetPlayer, GetMsg(msg, trade.targetPlayer));
SendReply(trade.sourcePlayer, GetMsg(msg2, trade.sourcePlayer));
}
void StartTrades(BasePlayer source, BasePlayer target)
{
var trade = new OpenTrade(onlinePlayers [source], onlinePlayers [target]);
StartTrade(source, target, trade);
if (source != target)
{
StartTrade(target, source, trade);
}
}
void TradeCloseBoxes(OpenTrade trade)
{
if (trade.IsSourceValid())
{
CloseBoxView(trade.sourcePlayer, trade.source.View);
}
if (trade.IsTargetValid() && trade.targetPlayer != trade.sourcePlayer)
{
CloseBoxView(trade.targetPlayer, trade.target.View);
}
}
void StartTrade(BasePlayer source, BasePlayer target, OpenTrade trade)
{
OpenBox(source, source);
if (!openTrades.Contains(trade))
{
openTrades.Add(trade);
}
onlinePlayers [source].Trade = trade;
timer.In(0.1f, () => ShowTrade(source, trade, GetMsg("Trade: Pending", source)));
}
void FinishTrade(OpenTrade t)
{
foreach (var i in t.source.View.inventory.itemList.ToArray())
{
i.MoveToContainer(t.target.containerMain);
}
foreach (var i in t.target.View.inventory.itemList.ToArray())
{
i.MoveToContainer(t.source.containerMain);
}
TradeCloseBoxes(t);
}
bool CheckTargetInventory(OpenTrade t)
{
var i = t.source.View.inventory.itemList.Count;
var f = t.target.containerMain.capacity - t.target.containerMain.itemList.Count;
if (i > f)
{
TradeReply(t, "Inventory: You", "Inventory: Them");
t.targetAccept = false;
ShowTrades(t, "Inventory: Generic");
return(false);
}
return(true);
}
void CompleteTrade(OpenTrade t)
{
if (t.IsInventorySufficient())
{
t.ResetAcceptance();
ShowTrades(t, "Inventory: Generic");
return;
}
if (t.complete)
{
return;
}
t.complete = true;
t.closing = true;
TradeCooldown(t);
TradeReply(t, "Status: Completing");
Interface.Oxide.NextTick(() => FinishTrade(t));
}
object CanMoveItem(Item item, PlayerInventory playerLoot, uint targetContainer, int targetSlot)
{
var player = playerLoot.GetComponent <BasePlayer> ();
if (player == null)
{
return(null);
}
OnlinePlayer onlinePlayer;
if (onlinePlayers.TryGetValue(player, out onlinePlayer) && onlinePlayer.Trade != null)
{
OpenTrade t = onlinePlayers [player].Trade;
if (t.closing)
{
return(false);
}
}
return(null);
}
void OnPlayerLootEnd(PlayerLoot inventory)
{
var player = inventory.GetComponent <BasePlayer> ();
if (player == null)
{
return;
}
OnlinePlayer onlinePlayer;
if (onlinePlayers.TryGetValue(player, out onlinePlayer) && onlinePlayer.View != null)
{
if (onlinePlayer.View == inventory.entitySource && onlinePlayer.Trade != null)
{
OpenTrade t = onlinePlayer.Trade;
if (!t.closing)
{
t.closing = true;
if (!onlinePlayer.Trade.complete)
{
if (onlinePlayer.Trade.sourcePlayer == player)
{
TradeReply(t, "Status: They Interrupted", "Status: You Interrupted");
}
else
{
TradeReply(t, "Status: You Interrupted", "Status: They Interrupted");
}
}
CloseBoxView(player, (StorageContainer)inventory.entitySource);
}
}
}
}
void CloseBoxView(BasePlayer player, StorageContainer view)
{
OnlinePlayer onlinePlayer;
if (!onlinePlayers.TryGetValue(player, out onlinePlayer))
{
return;
}
if (onlinePlayer.View == null)
{
return;
}
HideTrade(player);
if (onlinePlayer.Trade != null)
{
OpenTrade t = onlinePlayer.Trade;
t.closing = true;
if (t.sourcePlayer == player && t.targetPlayer != player && t.target.View != null)
{
t.target.Trade = null;
CloseBoxView(t.targetPlayer, t.target.View);
}
else if (t.targetPlayer == player && t.sourcePlayer != player && t.source.View != null)
{
t.source.Trade = null;
CloseBoxView(t.sourcePlayer, t.source.View);
}
if (openTrades.Contains(t))
{
openTrades.Remove(t);
}
}
if (view.inventory.itemList.Count > 0)
{
foreach (Item item in view.inventory.itemList.ToArray())
{
if (item.position != -1)
{
item.MoveToContainer(player.inventory.containerMain);
}
}
}
if (view.inventory.itemList.Count > 0)
{
foreach (Item item in view.inventory.itemList.ToArray())
{
if (item.position != -1)
{
item.MoveToContainer(player.inventory.containerBelt);
}
}
}
if (player.inventory.loot.entitySource != null)
{
player.inventory.loot.Invoke("SendUpdate", 0.1f);
view.SendMessage("PlayerStoppedLooting", player, SendMessageOptions.DontRequireReceiver);
player.SendConsoleCommand("inventory.endloot", null);
}
player.inventory.loot.entitySource = null;
player.inventory.loot.itemSource = null;
player.inventory.loot.containers = new List <ItemContainer> ();
view.inventory = new ItemContainer();
onlinePlayer.Clear();
view.Kill(BaseNetworkable.DestroyMode.None);
if (onlinePlayers.Values.Count(p => p.View != null) <= 0)
{
UnsubscribeAll();
}
}
private void ShowTrade(BasePlayer player, OpenTrade trade, string status)
{
HideTrade(player);
OnlinePlayer onlinePlayer;
if (!onlinePlayers.TryGetValue(player, out onlinePlayer))
{
return;
}
if (onlinePlayer.View == null)
{
return;
}
StorageContainer sourceContainer = onlinePlayer.View;
StorageContainer targetContainer = null;
BasePlayer target = null;
if (trade.sourcePlayer == player && trade.target.View != null)
{
targetContainer = trade.target.View;
target = trade.targetPlayer;
if (target is BasePlayer)
{
if (trade.targetAccept)
{
status += string.Format(GetMsg("Trade: They Accepted", player), CleanName(target.displayName));
}
else if (trade.sourceAccept)
{
status += GetMsg("Trade: You Accepted", player);
}
}
else
{
return;
}
}
else if (trade.targetPlayer == player && trade.source.View != null)
{
targetContainer = trade.source.View;
target = trade.sourcePlayer;
if (target is BasePlayer)
{
if (trade.sourceAccept)
{
status += string.Format(GetMsg("Trade: They Accepted", player), CleanName(target.displayName));
}
else if (trade.targetAccept)
{
status += GetMsg("Trade: You Accepted", player);
}
}
else
{
return;
}
}
if (targetContainer == null || target == null)
{
return;
}
string send = jsonTrade;
for (int i = 1; i < 100; i++)
{
send = send.Replace("{" + i + "}", Oxide.Core.Random.Range(9999, 99999).ToString());
}
send = send.Replace("{sourcename}", CleanName(player.displayName));
if (target != null)
{
send = send.Replace("{targetname}", CleanName(target.displayName));
}
else
{
send = send.Replace("{targetname}", GetMsg("Player: Unknown", player));
}
send = send.Replace("{targetstatus}", status);
var slotsAvailable = target.inventory.containerMain.capacity - (target.inventory.containerMain.itemList.Count);
List <string> sourceItems = new List <string> ();
var x = 1;
foreach (Item i in sourceContainer.inventory.itemList)
{
string n = "";
if (i.IsBlueprint())
{
n = i.amount + " x <color=lightblue>" + i.blueprintTargetDef.displayName.english + " [" + GetMsg("Item: BP", player) + "]</color>";
}
else
{
n = i.amount + " x " + i.info.displayName.english;
}
if (x > slotsAvailable)
{
n = "<color=red>" + n + "</color>";
}
x++;
sourceItems.Add(n);
}
send = send.Replace("{sourceitems}", string.Join("\n", sourceItems.ToArray()));
if (player != target)
{
slotsAvailable = player.inventory.containerMain.capacity - (player.inventory.containerMain.itemList.Count);
List <string> targetItems = new List <string> ();
x = 1;
if (targetContainer != null)
{
foreach (Item i in targetContainer.inventory.itemList)
{
string n2 = "";
if (i.IsBlueprint())
{
n2 = i.amount + " x <color=lightblue>" + i.blueprintTargetDef.displayName.english + " [" + GetMsg("Item: BP", player) + "]</color>";
}
else
{
n2 = i.amount + " x " + i.info.displayName.english;
}
if (x > slotsAvailable)
{
n2 = "<color=red>" + n2 + "</color>";
}
x++;
targetItems.Add(n2);
}
}
send = send.Replace("{targetitems}", string.Join("\n", targetItems.ToArray()));
}
else
{
send = send.Replace("{targetitems}", "");
}
CommunityEntity.ServerInstance.ClientRPCEx(new Network.SendInfo {
connection = player.net.connection
}, null, "AddUI", send);
}
public void Clear()
{
View = null;
Trade = null;
}
void ShowTrades(OpenTrade trade, string msg)
{
ShowTrade(trade.sourcePlayer, trade, GetMsg(msg, trade.sourcePlayer));
ShowTrade(trade.targetPlayer, trade, GetMsg(msg, trade.targetPlayer));
}
void TradeCooldown(OpenTrade trade)
{
PlayerCooldown(trade.targetPlayer);
PlayerCooldown(trade.sourcePlayer);
}
