Ejemplo n.º 1
0
        public override void ProcessServer()
        {
            if (!EconomyScript.Instance.ServerConfig.EnableNpcTradezones && !EconomyScript.Instance.ServerConfig.EnablePlayerTradezones)
            {
                MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "All Trade zones are disabled.");
                return;
            }

            switch (SellAction)
            {
                #region create

            case SellAction.Create:
            {
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create started by Steam Id '{0}'.", SenderSteamId);
                //* Logic:
                //* Get player steam ID
                var sellingPlayer = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);

                MyDefinitionBase    definition = null;
                MyObjectBuilderType result;
                if (MyObjectBuilderType.TryParse(ItemTypeId, out result))
                {
                    var id = new MyDefinitionId(result, ItemSubTypeName);
                    MyDefinitionManager.Static.TryGetDefinition(id, out definition);
                }

                if (definition == null)
                {
                    // Someone hacking, and passing bad data?
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the item you specified doesn't exist!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Definition could not be found for item during '/sell'; '{0}' '{1}'.", ItemTypeId, ItemSubTypeName);
                    return;
                }

                // Do a floating point check on the item item. Tools and components cannot have decimals. They must be whole numbers.
                if (definition.Id.TypeId != typeof(MyObjectBuilder_Ore) && definition.Id.TypeId != typeof(MyObjectBuilder_Ingot))
                {
                    if (ItemQuantity != Math.Truncate(ItemQuantity))
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You must provide a whole number for the quantity of that item.");
                        return;
                    }
                    //ItemQuantity = Math.Round(ItemQuantity, 0);  // Or do we just round the number?
                }

                if (ItemQuantity <= 0)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Invalid quantity, or you dont have any to trade!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- Invalid quantity.", SenderSteamId);
                    return;
                }

                // Who are we selling to?
                BankAccountStruct accountToBuy;
                if (SellToMerchant)
                {
                    accountToBuy = AccountManager.FindAccount(EconomyConsts.NpcMerchantId);
                }
                else
                {
                    accountToBuy = AccountManager.FindAccount(ToUserName);
                }

                if (accountToBuy == null)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, player does not exist or have an account!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- account not found.", SenderSteamId);
                    return;
                }

                if (MarketManager.IsItemBlacklistedOnServer(ItemTypeId, ItemSubTypeName))
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the item you tried to sell is blacklisted on this server.");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- Item is blacklisted.", SenderSteamId);
                    return;
                }

                // Verify that the items are in the player inventory.
                // TODO: later check trade block, cockpit inventory, cockpit ship inventory, inventory of targeted cube.

                // Get the player's inventory, regardless of if they are in a ship, or a remote control cube.
                var character = sellingPlayer.GetCharacter();
                // TODO: do players in Cryochambers count as a valid trading partner? They should be alive, but the connected player may be offline.
                // I think we'll have to do lower level checks to see if a physical player is Online.
                if (character == null)
                {
                    // Player has no body. Could mean they are dead.
                    // Either way, there is no inventory.
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You are dead. You cannot trade while dead.");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- player is dead.", SenderSteamId);
                    return;
                }

                // TODO: is a null check adaqaute?, or do we need to check for IsDead?
                // I don't think the chat console is accessible during respawn, only immediately after death.
                // Is it valid to be able to trade when freshly dead?
                //var identity = payingPlayer.Identity();
                //MyAPIGateway.Utilities.ShowMessage("CHECK", "Is Dead: {0}", identity.IsDead);

                //if (identity.IsDead)
                //{
                //    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You are dead. You cannot trade while dead.");
                //    return;
                //}

                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell finalizing by Steam Id '{0}' -- cataloging cargo cubes.", SenderSteamId);

                // Build list of all cargo blocks that player is attached to as pilot or passenger.
                var cargoBlocks     = new List <MyCubeBlock>();
                var tankBlocks      = new List <MyCubeBlock>();
                var controllingCube = sellingPlayer.Controller.ControlledEntity as IMyCubeBlock;
                if (controllingCube != null)
                {
                    var terminalsys = MyAPIGateway.TerminalActionsHelper.GetTerminalSystemForGrid(controllingCube.CubeGrid);
                    var blocks      = new List <IMyTerminalBlock>();
                    terminalsys.GetBlocksOfType <IMyCargoContainer>(blocks);
                    cargoBlocks.AddRange(blocks.Cast <MyCubeBlock>());

                    terminalsys.GetBlocksOfType <IMyGasTank>(blocks);
                    tankBlocks.AddRange(blocks.Cast <MyCubeBlock>());
                }

                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell finalizing by Steam Id '{0}' -- checking inventory.", SenderSteamId);

                var          position        = ((IMyEntity)character).WorldMatrix.Translation;
                var          playerInventory = character.GetPlayerInventory();
                MyFixedPoint amount          = (MyFixedPoint)ItemQuantity;
                var          storedAmount    = playerInventory.GetItemAmount(definition.Id);

                if (definition.Id.TypeId == typeof(MyObjectBuilder_GasProperties))
                {
                    foreach (MyCubeBlock cubeBlock in tankBlocks)
                    {
                        MyGasTankDefinition gasTankDefintion = cubeBlock.BlockDefinition as MyGasTankDefinition;

                        if (gasTankDefintion == null || gasTankDefintion.StoredGasId != definition.Id)
                        {
                            continue;
                        }

                        var tankLevel = ((IMyGasTank)cubeBlock).FilledRatio;
                        storedAmount += (MyFixedPoint)((decimal)tankLevel * (decimal)gasTankDefintion.Capacity);
                    }
                }
                else
                {
                    foreach (MyCubeBlock cubeBlock in cargoBlocks)
                    {
                        var cubeInventory = cubeBlock.GetInventory();
                        storedAmount += cubeInventory.GetItemAmount(definition.Id);
                    }
                }


                if (amount > storedAmount)
                {
                    // Insufficient items in inventory.
                    // TODO: use of definition.GetDisplayName() isn't localized here.

                    if ((definition.Id.TypeId != typeof(MyObjectBuilder_GasProperties) && cargoBlocks.Count == 0) &&
                        (definition.Id.TypeId == typeof(MyObjectBuilder_GasProperties) && tankBlocks.Count == 0))
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You don't have {0} of '{1}' to sell. You have {2} in your inventory.", ItemQuantity, definition.GetDisplayName(), storedAmount);
                    }
                    else
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You don't have {0} of '{1}' to sell. You have {2} in your player and cargo inventory.", ItemQuantity, definition.GetDisplayName(), storedAmount);
                    }

                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- inventory doesn't exist.", SenderSteamId);
                    return;
                }

                MarketItemStruct marketItem = null;

                if (SellToMerchant || UseBankBuyPrice)
                {
                    var markets = MarketManager.FindMarketsFromLocation(position);
                    if (markets.Count == 0)         //once again here is were we could put the multi market best price logic..
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, your are not in range of any markets!");
                        EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- no market in range.", SenderSteamId);
                        return;
                    }

                    // TODO: find market with best Buy price that isn't blacklisted.

                    var market = markets.FirstOrDefault();
                    if (market == null)
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the market you are accessing does not exist!");
                        EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- no market found.", SenderSteamId);
                        return;
                    }

                    accountToBuy = AccountManager.FindAccount(market.MarketId);

                    marketItem = market.MarketItems.FirstOrDefault(e => e.TypeId == ItemTypeId && e.SubtypeName == ItemSubTypeName);
                    if (marketItem == null)
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the items you are trying to sell doesn't have a market entry!");
                        // In reality, this shouldn't happen as all markets have their items synced up on start up of the mod.
                        return;
                    }

                    if (marketItem.IsBlacklisted)
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the item you tried to sell is blacklisted in this market.");
                        EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- item is blacklisted.", SenderSteamId);
                        return;
                    }


                    if (UseBankBuyPrice)
                    {
                        // The player is selling, but the *Market* will *buy* it from the player at this price.
                        // if we are not using price scaling OR the market we are trading with isn't owned by the NPC ID, dont change price. Otherwise scale.
                        if (!EconomyScript.Instance.ServerConfig.PriceScaling || accountToBuy.SteamId != EconomyConsts.NpcMerchantId)
                        {
                            ItemPrice = marketItem.BuyPrice;
                        }
                        else
                        {
                            ItemPrice = EconDataManager.PriceAdjust(marketItem.BuyPrice, marketItem.Quantity, PricingBias.Buy);
                        }
                    }
                    // if we are using price scaling adjust the price before our NPC trade (or check player for subsidy pricing)
                }

                var accountToSell = AccountManager.FindOrCreateAccount(SenderSteamId, SenderDisplayName, SenderLanguage);

                // need fix negative amounts before checking if the player can afford it.
                if (!sellingPlayer.IsAdmin())
                {
                    ItemPrice = Math.Abs(ItemPrice);
                }

                var transactionAmount = ItemPrice * ItemQuantity;

                if (!sellingPlayer.IsAdmin())
                {
                    transactionAmount = Math.Abs(transactionAmount);
                }

                if (SellToMerchant)         // && (merchant has enough money  || !EconomyScript.Instance.ServerConfig.LimitedSupply)
                                            //this is also a quick fix ideally npc should buy what it can afford and the rest is posted as a sell offer
                {
                    if (accountToBuy.SteamId != accountToSell.SteamId)
                    {
                        decimal limit = EconomyScript.Instance.ServerConfig.LimitedSupply ? marketItem.StockLimit - marketItem.Quantity : ItemQuantity;

                        if (limit == 0)
                        {
                            MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, you cannot sell any more {0} into this market.", definition.GetDisplayName());
                            return;
                        }
                        if (ItemQuantity > limit)
                        {
                            MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, you cannot sell any more than {0} of {1} into this market.", limit, definition.GetDisplayName());
                            return;
                        }
                    }

                    if (accountToBuy.BankBalance >= transactionAmount
                        // || !EconomyScript.Instance.ServerConfig.LimitedSupply // I'm not sure why we check limited supply when selling.
                        || accountToBuy.SteamId == accountToSell.SteamId)
                    {
                        // here we look up item price and transfer items and money as appropriate
                        EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell finalizing by Steam Id '{0}' -- removing inventory.", SenderSteamId);
                        RemoveInventory(playerInventory, cargoBlocks, tankBlocks, amount, definition.Id);
                        marketItem.Quantity += ItemQuantity;         // increment Market content.

                        if (accountToBuy.SteamId != accountToSell.SteamId)
                        {
                            accountToBuy.BankBalance -= transactionAmount;
                            accountToBuy.Date         = DateTime.Now;

                            accountToSell.BankBalance += transactionAmount;
                            accountToSell.Date         = DateTime.Now;
                            MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You just sold {0} {3} worth of {2} ({1} units)", transactionAmount, ItemQuantity, definition.GetDisplayName(), EconomyScript.Instance.ServerConfig.CurrencyName);

                            MessageUpdateClient.SendAccountMessage(accountToBuy);
                            MessageUpdateClient.SendAccountMessage(accountToSell);
                        }
                        else
                        {
                            accountToSell.Date = DateTime.Now;
                            MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "You just arranged transfer of {0} '{1}' into your market.", ItemQuantity, definition.GetDisplayName());
                        }
                    }
                    else
                    {
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "NPC can't afford {0} {4} worth of {2} ({1} units) NPC only has {3} funds!", transactionAmount, ItemQuantity, definition.GetDisplayName(), accountToBuy.BankBalance, EconomyScript.Instance.ServerConfig.CurrencyName);
                    }
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create completed by Steam Id '{0}' -- to NPC market.", SenderSteamId);
                    return;
                }

                if (OfferToMarket)
                {
                    // TODO: Here we post offer to appropriate zone market
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Offset to market at price is not yet available!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- Offer to market at price is not yet available.", SenderSteamId);
                    return;
                }

                // is it a player then?
                if (accountToBuy.SteamId == sellingPlayer.SteamUserId)
                {
                    // commented out for testing with myself.
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, you cannot sell to yourself!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- can't sell to self.", SenderSteamId);
                    return;
                }

                // check if buying player is online and in range?
                var buyingPlayer = MyAPIGateway.Players.FindPlayerBySteamId(accountToBuy.SteamId);

                if (EconomyScript.Instance.ServerConfig.LimitedRange && !Support.RangeCheck(buyingPlayer, sellingPlayer))
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, you are not in range of that player!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- target player not in range.", SenderSteamId);
                    return;
                }

                // if other player online, send message.
                if (buyingPlayer == null)
                {
                    // TODO: other player offline.

                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You cannot sell to offline players at this time.");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create aborted by Steam Id '{0}' -- cannot sell to offline player.", SenderSteamId);
                    return;

                    // TODO: we need a way to queue up messages.
                    // While you were gone....
                    // You missed an offer for 4000Kg of Gold for 20,000.
                }
                else
                {
                    // The other player is online.

                    // write to Trade offer table.
                    MarketManager.CreateTradeOffer(SenderSteamId, ItemTypeId, ItemSubTypeName, ItemQuantity, ItemPrice, accountToBuy.SteamId);

                    // remove items from inventory.
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell finalizing by Steam Id '{0}' -- removing inventory.", SenderSteamId);
                    RemoveInventory(playerInventory, cargoBlocks, tankBlocks, amount, definition.Id);

                    // Only send message to targeted player if this is the only offer pending for them.
                    // Otherwise it will be sent when the have with previous orders in their order Queue.
                    if (EconomyScript.Instance.Data.OrderBook.Count(e => (e.OptionalId == accountToBuy.SteamId.ToString() && e.TradeState == TradeState.SellDirectPlayer)) == 1)
                    {
                        MessageClientTextMessage.SendMessage(accountToBuy.SteamId, "SELL",
                                                             "You have received an offer from {0} to buy {1} {2} at price {3} {4} each - type '/sell accept' to accept offer (or '/sell deny' to reject and return item to seller)",
                                                             SenderDisplayName, ItemQuantity, definition.GetDisplayName(), ItemPrice, EconomyScript.Instance.ServerConfig.CurrencyName);
                    }

                    // TODO: Improve the message here, to say who were are trading to, and that the item is gone from inventory.
                    // send message to seller to confirm action, "Your Trade offer has been submitted, and the goods removed from you inventory."
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Your offer of {0} {1} for {2} {4} each has been sent to {3}.", ItemQuantity, definition.GetDisplayName(), ItemPrice, accountToBuy.NickName, EconomyScript.Instance.ServerConfig.CurrencyName);

                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Create completed by Steam Id '{0}' -- to another player.", SenderSteamId);
                    return;
                }
            }

                #endregion

                #region accept

            case SellAction.Accept:
            {
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Accept started by Steam Id '{0}'.", SenderSteamId);
                var order = EconomyScript.Instance.Data.OrderBook.FirstOrDefault(e => e.OptionalId == SenderSteamId.ToString() && e.TradeState == TradeState.SellDirectPlayer);
                if (order == null)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "There are no outstanding orders to be accepted.");
                    return;
                }

                var payingPlayer = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);

                // get the accounts and check finance.
                var accountToBuy = AccountManager.FindAccount(ulong.Parse(order.OptionalId));

                var transactionAmount = order.Price * order.Quantity;

                // need fix negative amounts before checking if the player can afford it.
                if (!payingPlayer.IsAdmin())
                {
                    transactionAmount = Math.Abs(transactionAmount);
                }

                if (accountToBuy.BankBalance < transactionAmount)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You cannot afford {0} {1} at this time.", transactionAmount, EconomyScript.Instance.ServerConfig.CurrencyName);
                    return;
                }

                var accountToSell = AccountManager.FindAccount(order.TraderId);

                // rebalance accounts.
                accountToBuy.BankBalance -= transactionAmount;
                accountToBuy.Date         = DateTime.Now;

                accountToSell.BankBalance += transactionAmount;
                accountToSell.Date         = DateTime.Now;

                MessageUpdateClient.SendAccountMessage(accountToBuy);
                MessageUpdateClient.SendAccountMessage(accountToSell);

                order.TradeState = TradeState.SellAccepted;

                var definition = MyDefinitionManager.Static.GetDefinition(order.TypeId, order.SubtypeName);

                if (definition == null)
                {
                    // Someone hacking, and passing bad data?
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the item in your order doesn't exist!");

                    // trade has been finalized, so we can exit safely.
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Definition could not be found for item during '/sell accept'; '{0}' '{1}'.", order.TypeId, order.SubtypeName);
                    return;
                }

                // TODO: Improve the messages.
                // message back "Your Trade offer of xxx to yyy has been accepted. You have recieved zzzz"
                MessageClientTextMessage.SendMessage(accountToSell.SteamId, "SELL", "You just sold {0} {3} worth of {2} ({1} units)", transactionAmount, order.Quantity, definition.GetDisplayName(), EconomyScript.Instance.ServerConfig.CurrencyName);

                var  collectingPlayer    = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
                var  playerInventory     = collectingPlayer.GetPlayerInventory();
                bool hasAddedToInventory = true;

                if (playerInventory != null)
                {
                    MyFixedPoint amount = (MyFixedPoint)order.Quantity;
                    hasAddedToInventory = Support.InventoryAdd(playerInventory, amount, definition.Id);
                }

                if (hasAddedToInventory)
                {
                    EconomyScript.Instance.Data.OrderBook.Remove(order);         // item has been collected, so the order is finalized.
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You just purchased {0} {3} worth of {2} ({1} units) which are now in your player inventory.", transactionAmount, order.Quantity, definition.GetDisplayName(), EconomyScript.Instance.ServerConfig.CurrencyName);
                }
                else
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You just purchased {0} {3} worth of {2} ({1} units). Enter '/collect' when you are ready to receive them.", transactionAmount, order.Quantity, definition.GetDisplayName(), EconomyScript.Instance.ServerConfig.CurrencyName);
                }

                // Send message to player if additional offers are pending their attention.
                DisplayNextOrderToAccept(SenderSteamId);

                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Accept completed by Steam Id '{0}'.", SenderSteamId);
                return;
            }

                #endregion

                #region collect

            case SellAction.Collect:
            {
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Collect or /collect started by Steam Id '{0}'.", SenderSteamId);
                var collectableOrders = EconomyScript.Instance.Data.OrderBook.Where(e =>
                                                                                    (e.TraderId == SenderSteamId && e.TradeState == TradeState.SellTimedout) ||
                                                                                    (e.TraderId == SenderSteamId && e.TradeState == TradeState.Holding) ||
                                                                                    (e.TraderId == SenderSteamId && e.TradeState == TradeState.SellRejected) ||
                                                                                    (e.OptionalId == SenderSteamId.ToString() && e.TradeState == TradeState.SellAccepted)).ToArray();

                if (collectableOrders.Length == 0)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "There is nothing to collect currently.");
                    return;
                }

                var collectingPlayer = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);

                // TODO: this is just for debugging until the message below are completed....
                //MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You are collecting items from {0} order/s.", collectableOrders.Length);

                foreach (var order in collectableOrders)
                {
                    MyDefinitionBase    definition = null;
                    MyObjectBuilderType result;
                    if (MyObjectBuilderType.TryParse(order.TypeId, out result))
                    {
                        var id = new MyDefinitionId(result, order.SubtypeName);
                        MyDefinitionManager.Static.TryGetDefinition(id, out definition);
                    }

                    if (definition == null)
                    {
                        // Someone hacking, and passing bad data?
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the item in your order doesn't exist!");
                        // TODO: more detail on the item.
                        EconomyScript.Instance.ServerLogger.WriteVerbose("Definition could not be found for item during '/sell collect or /collect'; '{0}' '{1}'.", order.TypeId, order.SubtypeName);
                        continue;
                    }

                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell finalizing by Steam Id '{0}' -- adding to inventories.", SenderSteamId);
                    var remainingToCollect = MessageSell.AddToInventories(collectingPlayer, order.Quantity, definition.Id);
                    var collected          = order.Quantity - remainingToCollect;

                    if (remainingToCollect == 0)
                    {
                        EconomyScript.Instance.Data.OrderBook.Remove(order);
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You just collected {0} worth of {2} ({1} units)", order.Price * collected, collected, definition.GetDisplayName());
                    }
                    else
                    {
                        order.Quantity = remainingToCollect;
                        MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You just collected {0} worth of {2} ({1} units). There are {3} remaining.", order.Price * collected, collected, definition.GetDisplayName(), remainingToCollect);
                    }
                }

                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Collect completed by Steam Id '{0}'.", SenderSteamId);
                return;
            }

                #endregion

                #region cancel

            case SellAction.Cancel:
            {
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Cancel started by Steam Id '{0}'.", SenderSteamId);
                var cancellableOrders = EconomyScript.Instance.Data.OrderBook.Where(e =>
                                                                                    (e.TraderId == SenderSteamId && e.TradeState == TradeState.SellDirectPlayer)).OrderByDescending(e => e.Created).ToArray();

                if (cancellableOrders.Length == 0)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "There is nothing to cancel currently.");
                }

                // Sellers should be presented with the newest order first, as they will be the most recently created.
                // use of OrderByDescending above assures us that [0] is the most recent order added.
                var order = cancellableOrders[0];
                order.TradeState = TradeState.SellRejected;

                var definition = MyDefinitionManager.Static.GetDefinition(order.TypeId, order.SubtypeName);

                if (definition == null)
                {
                    // Someone hacking, and passing bad data?
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the item in your order doesn't exist!");

                    // trade has been finalized, so we can exit safely.
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Definition could not be found for item during '/sell cancel'; '{0}' '{1}'.", order.TypeId, order.SubtypeName);
                    return;
                }

                var  transactionAmount   = order.Price * order.Quantity;
                var  collectingPlayer    = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
                var  inventory           = collectingPlayer.GetPlayerInventory();
                bool hasAddedToInventory = true;

                if (inventory != null)
                {
                    MyFixedPoint amount = (MyFixedPoint)order.Quantity;
                    hasAddedToInventory = Support.InventoryAdd(inventory, amount, definition.Id);
                }

                if (hasAddedToInventory)
                {
                    EconomyScript.Instance.Data.OrderBook.Remove(order);         // item has been collected, so the order is finalized.
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You just cancelled the sale of {2} ({1} units) for a total of {0} {3} which are now in your inventory.", transactionAmount, order.Quantity, definition.GetDisplayName(), EconomyScript.Instance.ServerConfig.CurrencyName);
                }
                else
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "You just cancelled the sale of {2} ({1} units) for a total of {0} {3}. Enter '/sell collect' when you are ready to receive them.", transactionAmount, order.Quantity, definition.GetDisplayName(), EconomyScript.Instance.ServerConfig.CurrencyName);
                }

                cancellableOrders = EconomyScript.Instance.Data.OrderBook.Where(e =>
                                                                                (e.TraderId == SenderSteamId && e.TradeState == TradeState.SellDirectPlayer)).OrderByDescending(e => e.Created).ToArray();

                if (cancellableOrders.Length > 0)
                {
                    // TODO: Inform the player of the next order in the queue that can be cancelled.
                }

                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Cancel completed by Steam Id '{0}'.", SenderSteamId);
                return;
            }

                #endregion

                #region deny

            case SellAction.Deny:
            {
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Deny started by Steam Id '{0}'.", SenderSteamId);
                var buyOrdersForMe = EconomyScript.Instance.Data.OrderBook.Where(e =>
                                                                                 (e.OptionalId == SenderSteamId.ToString() && e.TradeState == TradeState.SellDirectPlayer)).OrderBy(e => e.Created).ToArray();

                if (buyOrdersForMe.Length == 0)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "There is nothing to deny currently.");
                }

                // Buyers should be presented with the oldest order first, as they will timout first.
                // use of OrderBy above assures us that [0] is the most oldest order added.
                var order = buyOrdersForMe[0];
                order.TradeState = TradeState.SellRejected;

                var definition = MyDefinitionManager.Static.GetDefinition(order.TypeId, order.SubtypeName);

                if (definition == null)
                {
                    // Someone hacking, and passing bad data?
                    MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Sorry, the item in your order doesn't exist!");

                    // trade has been finalized, so we can exit safely.
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Definition could not be found for item during '/sell deny'; '{0}' '{1}'.", order.TypeId, order.SubtypeName);
                    return;
                }

                var transactionAmount = order.Price * order.Quantity;
                var buyerId           = ulong.Parse(order.OptionalId);
                MessageClientTextMessage.SendMessage(buyerId, "SELL", "You just rejected the purchase of {2} ({1} units) for a total of {0} {3}.", transactionAmount, order.Quantity, definition.GetDisplayName(), EconomyScript.Instance.ServerConfig.CurrencyName);

                // TODO: return items to inventory automatically to Trader inventory if there is space.
                MessageClientTextMessage.SendMessage(order.TraderId, "SELL", "{3} has just rejected your offer of {2} ({1} units) for a total of {0} {4}. Enter '/sell collect' when you are ready to receive them.", transactionAmount, order.Quantity, definition.GetDisplayName(), SenderDisplayName, EconomyScript.Instance.ServerConfig.CurrencyName);

                // Send message to player if additional offers are pending their attention.
                DisplayNextOrderToAccept(SenderSteamId);

                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Sell Deny completed by Steam Id '{0}'.", SenderSteamId);
                return;
            }

                #endregion
            }

            // this is a fall through from the above conditions not yet complete.
            MessageClientTextMessage.SendMessage(SenderSteamId, "SELL", "Not yet complete.");
        }
Ejemplo n.º 2
0
        public override void ProcessServer()
        {
            EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy started by Steam Id '{0}'.", SenderSteamId);

            // Get player steam ID
            var buyingPlayer = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);

            MyPhysicalItemDefinition definition = null;
            MyObjectBuilderType      result;

            if (MyObjectBuilderType.TryParse(ItemTypeId, out result))
            {
                var id = new MyDefinitionId(result, ItemSubTypeName);
                MyDefinitionManager.Static.TryGetPhysicalItemDefinition(id, out definition);
            }

            if (definition == null)
            {
                // Someone hacking, and passing bad data?
                MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, the item you specified doesn't exist!");
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- item doesn't exist.", SenderSteamId);
                return;
            }

            // Do a floating point check on the item item. Tools and components cannot have decimals. They must be whole numbers.
            if (definition.Id.TypeId != typeof(MyObjectBuilder_Ore) && definition.Id.TypeId != typeof(MyObjectBuilder_Ingot))
            {
                if (ItemQuantity != Math.Truncate(ItemQuantity))
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "You must provide a whole number for the quantity to buy that item.");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- invalid qantity.", SenderSteamId);
                    return;
                }
                //ItemQuantity = Math.Round(ItemQuantity, 0);  // Or do we just round the number?
            }

            if (ItemQuantity <= 0)
            {
                MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "You must provide a valid quantity to buy.");
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- invalid qantity.", SenderSteamId);
                return;
            }

            // Who are we buying to?
            BankAccountStruct accountToSell;

            if (BuyFromMerchant)
            {
                accountToSell = AccountManager.FindAccount(EconomyConsts.NpcMerchantId);
            }
            else
            {
                accountToSell = AccountManager.FindAccount(FromUserName);
            }

            if (accountToSell == null)
            {
                MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, player does not exist or have an account!");
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- no account.", SenderSteamId);
                return;
            }

            if (MarketManager.IsItemBlacklistedOnServer(ItemTypeId, ItemSubTypeName))
            {
                MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, the item you tried to buy is blacklisted on this server.");
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- item blacklisted.", SenderSteamId);
                return;
            }

            // Get the player's inventory, regardless of if they are in a ship, or a remote control cube.
            var character = buyingPlayer.GetCharacter();

            // TODO: do players in Cryochambers count as a valid trading partner? They should be alive, but the connected player may be offline.
            // I think we'll have to do lower level checks to see if a physical player is Online.
            if (character == null)
            {
                // Player has no body. Could mean they are dead.
                // Either way, there is no inventory.
                MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "You are dead. You cannot trade while dead.");
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- player is dead.", SenderSteamId);
                return;
            }

            // TODO: is a null check adaqaute?, or do we need to check for IsDead?
            // I don't think the chat console is accessible during respawn, only immediately after death.
            // Is it valid to be able to trade when freshly dead?
            //var identity = buyingPlayer.Identity();
            //MyAPIGateway.Utilities.ShowMessage("CHECK", "Is Dead: {0}", identity.IsDead);

            //if (identity.IsDead)
            //{
            //    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "You are dead. You cannot trade while dead.");
            //    return;
            //}

            var position = ((IMyEntity)character).WorldMatrix.Translation;

            MarketItemStruct marketItem = null;

            if (BuyFromMerchant || UseBankSellPrice)
            {
                var markets = MarketManager.FindMarketsFromLocation(position);
                if (markets.Count == 0)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, your are not in range of any markets!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- no market in range.", SenderSteamId);
                    return;
                }

                // TODO: find market with best Sell price that isn't blacklisted.

                var market = markets.FirstOrDefault();
                if (market == null)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, the market you are accessing does not exist!");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- no market found.", SenderSteamId);
                    return;
                }

                marketItem = market.MarketItems.FirstOrDefault(e => e.TypeId == ItemTypeId && e.SubtypeName == ItemSubTypeName);
                if (marketItem == null)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, the items you are trying to buy doesn't have a market entry!");
                    // In reality, this shouldn't happen as all markets have their items synced up on start up of the mod.
                    return;
                }

                if (marketItem.IsBlacklisted)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, the item you tried to buy is blacklisted in this market.");
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- item is blacklisted in market.", SenderSteamId);
                    return;
                }

                // Verify that the items are in the player inventory.
                // TODO: later check trade block, cockpit inventory, cockpit ship inventory, inventory of targeted cube.

                if (UseBankSellPrice)
                {
                    // The player is buying, but the *Market* will *sell* it to the player at this price.
                    ItemPrice = marketItem.SellPrice;
                }
            }

            var accountToBuy      = AccountManager.FindOrCreateAccount(SenderSteamId, SenderDisplayName, SenderLanguage);
            var transactionAmount = ItemPrice * ItemQuantity;

            // need fix negative amounts before checking if the player can afford it.
            if (!buyingPlayer.IsAdmin())
            {
                transactionAmount = Math.Abs(transactionAmount);
            }

            // TODO: admin check on ability to afford it?
            //[maybe later, our pay and reset commands let us steal money from npc anyway best to keep admin abuse features to minimum]
            //[we could put an admin check on blacklist however, allow admins to spawn even blacklisted gear]
            if (accountToBuy.BankBalance < transactionAmount)
            {
                MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, you cannot afford {0} {1}!", transactionAmount, EconomyScript.Instance.Config.CurrencyName);
                EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- not enough money.", SenderSteamId);
                return;
            }

            if (BuyFromMerchant) // and supply is not exhausted, or unlimited mode is not on.
                                 //This is a quick fix, ideally it should do a partial buy of what is left and post a buy offer for remainder
            {
                // here we look up item price and transfer items and money as appropriate
                if (marketItem.Quantity >= ItemQuantity || !EconomyScript.Instance.Config.LimitedSupply)
                {
                    marketItem.Quantity -= ItemQuantity; // reduce Market content.
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy finalizing by Steam Id '{0}' -- adding to inventory.", SenderSteamId);
                    var remainingToCollect = MessageSell.AddToInventories(buyingPlayer, ItemQuantity, definition.Id);

                    //EconomyScript.Instance.Config.LimitedSupply

                    accountToSell.BankBalance += transactionAmount;
                    accountToSell.Date         = DateTime.Now;

                    accountToBuy.BankBalance -= transactionAmount;
                    accountToBuy.Date         = DateTime.Now;
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "You just purchased {1} '{2}' for {0} {3}", transactionAmount, ItemQuantity, definition.GetDisplayName(), EconomyScript.Instance.Config.CurrencyName);

                    if (remainingToCollect > 0)
                    {
                        MarketManager.CreateStockHeld(buyingPlayer.SteamUserId, ItemTypeId, ItemSubTypeName, remainingToCollect, ItemPrice);
                        // TODO: there should be a common command to collect items. Not use /sell.
                        MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "There are {0} remaining to collect. Use '/sell collect'", remainingToCollect);
                    }
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy complete by Steam Id '{0}' -- items bought.", SenderSteamId);
                }
                else
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "There isn't '{0}' of {1} available to purchase! Only {2} available to buy!", ItemQuantity, definition.GetDisplayName(), marketItem.Quantity);
                    EconomyScript.Instance.ServerLogger.WriteVerbose("Action /Buy aborted by Steam Id '{0}' -- not enough stock.", SenderSteamId);
                }

                return;
            }
            else if (FindOnMarket)
            {
                // TODO: Here we find the best offer on the zone market

                return;
            }
            else
            {
                // is it a player then?
                if (accountToSell.SteamId == buyingPlayer.SteamUserId)
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, you cannot buy from yourself!");
                    return;
                }

                // check if selling player is online and in range?
                var payingPlayer = MyAPIGateway.Players.FindPlayerBySteamId(accountToSell.SteamId);

                if (EconomyScript.Instance.Config.LimitedRange && !Support.RangeCheck(buyingPlayer, payingPlayer))
                {
                    MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Sorry, you are not in range of that player!");
                    return;
                }

                if (payingPlayer == null)
                {
                    // TODO: other player offline.
                }
                else
                {
                    // TODO: other player is online.
                }
            }

            // this is a fall through from the above conditions not yet complete.
            MessageClientTextMessage.SendMessage(SenderSteamId, "BUY", "Not yet complete.");
        }