| public static SendMessage ( ulong steamId, string title, string prefix, string content ) : void | ||
| steamId | ulong | |
| title | string | |
| prefix | string | |
| content | string | |
| return | void | |
public override void ProcessServer()
{
var player = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
if (player != null && player.IsAdmin()) // hold on there, are we an admin first?
{
var description = new StringBuilder();
var index = 1;
//probably should add column headings too.. ie number, opened, name, balance, lastseen etc
foreach (var account in EconomyScript.Instance.Data.Clients.OrderBy(s => s.NickName))
{
description.AppendFormat("#{0}: {1} : {2} : {3}\r\n", index++, account.NickName, account.BankBalance, account.Date);
// TODO: https://github.com/jpcsupplies/Economy_mod/issues/54
}
MessageClientDialogMessage.SendMessage(SenderSteamId, "List Accounts",
string.Format("Count: {0}", EconomyScript.Instance.Data.Clients.Count),
description.ToString());
// update our own timestamp here
AccountManager.UpdateLastSeen(SenderSteamId, SenderLanguage);
}
}
public override void ProcessServer()
{
var player = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
// Only Admin can change Npc Market prices.
if (!player.IsAdmin() && MarketId == EconomyConsts.NpcMerchantId)
{
EconomyScript.Instance.ServerLogger.WriteWarning("A Player without Admin \"{0}\" {1} attempted to set Default Market characteristics of item {2}/{3} to Quantity={4}.", SenderDisplayName, SenderSteamId, ItemTypeId, ItemSubTypeName, ItemQuantity);
return;
}
// Only Player can change their own Market prices.
if (SenderSteamId != MarketId && MarketId != EconomyConsts.NpcMerchantId)
{
EconomyScript.Instance.ServerLogger.WriteWarning("A Player \"{0}\" {1} attempted to set another Market characteristics of item {2}/{3} to Quantity={4}.", SenderDisplayName, SenderSteamId, ItemTypeId, ItemSubTypeName, ItemQuantity);
return;
}
// TODO: do we check range to market?
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)
{
// Passing bad data?
MessageClientTextMessage.SendMessage(SenderSteamId, "SET", "Sorry, the item you specified doesn't exist!");
return;
}
if (SetType.HasFlag(SetMarketItemType.Quantity))
{
// 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, "SET", "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, "SET", "Invalid quantity specified");
return;
}
}
// Find the specified market.
List <MarketStruct> markets;
if (string.IsNullOrEmpty(MarketZone))
{
var character = player.GetCharacter();
if (character == null)
{
// Player has no body. Could mean they are dead.
MessageClientTextMessage.SendMessage(SenderSteamId, "SET", "There is no market at your location to set.");
return;
}
var position = ((IMyEntity)character).WorldMatrix.Translation;
markets = MarketManager.FindMarketsFromLocation(position).Where(m => m.MarketId == MarketId).ToList();
}
else
{
markets = EconomyScript.Instance.Data.Markets.Where(m => m.MarketId == MarketId && (MarketZone == "*" || m.DisplayName.Equals(MarketZone, StringComparison.InvariantCultureIgnoreCase))).ToList();
}
if (markets.Count == 0)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "SET", "Sorry, you are not near any markets currently or the market does not exist!");
return;
}
var msg = new StringBuilder();
msg.AppendFormat("Applying changes to : '{0}' {1}/{2}\r\n\r\n", definition.GetDisplayName(), ItemTypeId, ItemSubTypeName);
foreach (var market in markets)
{
msg.AppendFormat("Market: '{0}'\r\n", market.DisplayName);
var marketItem = market.MarketItems.FirstOrDefault(e => e.TypeId == ItemTypeId && e.SubtypeName == ItemSubTypeName);
if (marketItem == null)
{
msg.AppendLine("Sorry, the items you are trying to set 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.
continue;
}
if (SetType.HasFlag(SetMarketItemType.Quantity))
{
marketItem.Quantity = ItemQuantity;
msg.AppendFormat("Stock on hand to {0} units", ItemQuantity);
}
// Validation to prevent admins setting prices too low for items.
if (SetType.HasFlag(SetMarketItemType.BuyPrice))
{
if (ItemBuyPrice >= 0)
{
marketItem.BuyPrice = ItemBuyPrice;
msg.AppendFormat("Buy price to {0}", ItemBuyPrice);
}
else
{
msg.AppendFormat("Could not set buy price to less than 0.");
}
}
// Validation to prevent admins setting prices too low for items.
if (SetType.HasFlag(SetMarketItemType.SellPrice))
{
if (ItemSellPrice >= 0)
{
marketItem.SellPrice = ItemSellPrice;
msg.AppendFormat("Sell price to {0}", ItemSellPrice);
}
else
{
msg.AppendFormat("Could not set sell price to less than 0.");
}
}
if (SetType.HasFlag(SetMarketItemType.Blacklisted))
{
marketItem.IsBlacklisted = !marketItem.IsBlacklisted;
msg.AppendFormat("Blacklist to {0}", marketItem.IsBlacklisted ? "On" : "Off");
}
msg.AppendLine();
msg.AppendLine();
}
#region update config for the item
MarketItemStruct configItem = null;
if (player.IsAdmin() && MarketId == EconomyConsts.NpcMerchantId)
{
configItem = EconomyScript.Instance.ServerConfig.DefaultPrices.FirstOrDefault(e => e.TypeId == ItemTypeId && e.SubtypeName == ItemSubTypeName);
}
if (configItem != null)
{
if (SetType.HasFlag(SetMarketItemType.BuyPrice))
{
if (ItemBuyPrice >= 0)
{
configItem.BuyPrice = ItemBuyPrice;
msg.AppendFormat("Config updated Buy price to {0}", ItemBuyPrice);
}
}
// Validation to prevent admins setting prices too low for items.
if (SetType.HasFlag(SetMarketItemType.SellPrice))
{
if (ItemSellPrice >= 0)
{
configItem.SellPrice = ItemSellPrice;
msg.AppendFormat("Config updated Sell price to {0}", ItemSellPrice);
}
}
if (SetType.HasFlag(SetMarketItemType.Blacklisted))
{
configItem.IsBlacklisted = !configItem.IsBlacklisted;
msg.AppendFormat("Config updated Blacklist to {0}", configItem.IsBlacklisted ? "On" : "Off");
// If config blacklisted, then all markets should be updated.
if (configItem.IsBlacklisted)
{
int counter = 0;
foreach (var market in EconomyScript.Instance.Data.Markets)
{
var marketItem = market.MarketItems.FirstOrDefault(e => e.TypeId == ItemTypeId && e.SubtypeName == ItemSubTypeName);
if (marketItem != null && !marketItem.IsBlacklisted)
{
counter++;
marketItem.IsBlacklisted = true;
}
}
msg.AppendFormat("Config updated {0} Markets to also Blacklist to {1}.", counter, configItem.IsBlacklisted ? "On" : "Off");
}
}
}
#endregion
MessageClientDialogMessage.SendMessage(SenderSteamId, "SET", " ", msg.ToString());
}
public override void ProcessServer()
{
// update our own timestamp here
AccountManager.UpdateLastSeen(SenderSteamId, SenderLanguage);
EconomyScript.Instance.ServerLogger.WriteVerbose("Manage Npc Market Request for from '{0}'", SenderSteamId);
var player = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
if (player == null || !player.IsAdmin()) // hold on there, are we an admin first?
{
return;
}
switch (CommandType)
{
case NpcMarketManage.Add:
{
if (string.IsNullOrWhiteSpace(MarketName) || MarketName == "*")
{
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC ADD", "Invalid name supplied for the market name.");
return;
}
var checkMarket = EconomyScript.Instance.Data.Markets.FirstOrDefault(m => m.DisplayName.Equals(MarketName, StringComparison.InvariantCultureIgnoreCase));
if (checkMarket != null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC ADD", "A market of name '{0}' already exists.", checkMarket.DisplayName);
return;
}
// TODO: market inside market check?
EconDataManager.CreateNpcMarket(MarketName, X, Y, Z, Size, Shape);
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC ADD", "A new market called '{0}' has been created.", MarketName);
}
break;
case NpcMarketManage.Delete:
{
var market = EconomyScript.Instance.Data.Markets.FirstOrDefault(m => m.DisplayName.Equals(MarketName, StringComparison.InvariantCultureIgnoreCase));
if (market == null)
{
var markets = EconomyScript.Instance.Data.Markets.Where(m => m.DisplayName.IndexOf(MarketName, StringComparison.InvariantCultureIgnoreCase) >= 0).ToArray();
if (markets.Length == 0)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC DELETE", "The specified market name could not be found.");
return;
}
if (markets.Length > 1)
{
var str = new StringBuilder();
str.Append("The specified market name could not be found.\r\n Which did you mean?\r\n");
foreach (var m in markets)
{
str.AppendLine(m.DisplayName);
}
MessageClientDialogMessage.SendMessage(SenderSteamId, "NPC DELETE", " ", str.ToString());
return;
}
market = markets[0];
}
EconomyScript.Instance.Data.Markets.Remove(market);
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC DELETE", "The market '{0}' has been removed and all inventory.", market.DisplayName);
}
break;
case NpcMarketManage.List:
{
var str = new StringBuilder();
foreach (var market in EconomyScript.Instance.Data.Markets)
{
if (market.MarketId != EconomyConsts.NpcMerchantId)
{
continue;
}
str.AppendFormat("Market: {0}\r\n", market.DisplayName);
str.AppendFormat("{0}", market.MarketZoneType);
if (market.MarketZoneType == MarketZoneType.FixedSphere && market.MarketZoneSphere.HasValue)
{
str.AppendFormat(" Center Position=X:{0:N} | Y:{1:N} | Z:{2:N} Radius={3:N}m\r\n\r\n", market.MarketZoneSphere.Value.Center.X, market.MarketZoneSphere.Value.Center.Y, market.MarketZoneSphere.Value.Center.Z, market.MarketZoneSphere.Value.Radius);
}
else if (market.MarketZoneType == MarketZoneType.FixedBox && market.MarketZoneBox.HasValue)
{
str.AppendFormat(" Center Position=X:{0:N} | Y:{1:N} | Z:{2:N} Size={3:N}m\r\n\r\n", market.MarketZoneBox.Value.Center.X, market.MarketZoneBox.Value.Center.Y, market.MarketZoneBox.Value.Center.Z, market.MarketZoneBox.Value.Size.X);
}
else
{
str.AppendLine("\r\n");
}
}
MessageClientDialogMessage.SendMessage(SenderSteamId, "NPC Market List", " ", str.ToString());
}
break;
case NpcMarketManage.Rename:
{
var market = EconomyScript.Instance.Data.Markets.FirstOrDefault(m => m.DisplayName.Equals(OldMarketName, StringComparison.InvariantCultureIgnoreCase));
if (market == null)
{
var markets = EconomyScript.Instance.Data.Markets.Where(m => m.DisplayName.IndexOf(OldMarketName, StringComparison.InvariantCultureIgnoreCase) >= 0).ToArray();
if (markets.Length == 0)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC RENAME", "The specified market name could not be found.");
return;
}
if (markets.Length > 1)
{
var str = new StringBuilder();
str.Append("The specified market name could not be found.\r\n Which did you mean?\r\n");
foreach (var m in markets)
{
str.AppendLine(m.DisplayName);
}
MessageClientDialogMessage.SendMessage(SenderSteamId, "NPC RENAME", " ", str.ToString());
return;
}
market = markets[0];
}
if (string.IsNullOrWhiteSpace(MarketName) || MarketName == "*")
{
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC RENAME", "Invalid name supplied for the market name.");
return;
}
var checkMarket = EconomyScript.Instance.Data.Markets.FirstOrDefault(m => m.DisplayName.Equals(MarketName, StringComparison.InvariantCultureIgnoreCase));
if (checkMarket != null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC RENAME", "A market of name '{0}' already exists.", checkMarket.DisplayName);
return;
}
var oldName = market.DisplayName;
market.DisplayName = MarketName;
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC RENAME", "The market '{0}' has been renamed to '{1}.", oldName, market.DisplayName);
}
break;
case NpcMarketManage.Move:
{
var market = EconomyScript.Instance.Data.Markets.FirstOrDefault(m => m.DisplayName.Equals(MarketName, StringComparison.InvariantCultureIgnoreCase));
if (market == null)
{
var markets = EconomyScript.Instance.Data.Markets.Where(m => m.DisplayName.IndexOf(MarketName, StringComparison.InvariantCultureIgnoreCase) >= 0).ToArray();
if (markets.Length == 0)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC MOVE", "The specified market name could not be found.");
return;
}
if (markets.Length > 1)
{
var str = new StringBuilder();
str.Append("The specified market name could not be found.\r\n Which did you mean?\r\n");
foreach (var m in markets)
{
str.AppendLine(m.DisplayName);
}
MessageClientDialogMessage.SendMessage(SenderSteamId, "NPC MOVE", " ", str.ToString());
return;
}
market = markets[0];
}
EconDataManager.SetMarketShape(market, X, Y, Z, Size, Shape);
MessageClientTextMessage.SendMessage(SenderSteamId, "NPC MOVE", "The market '{0}' has been moved and resized.", market.DisplayName);
}
break;
}
}
public override void ProcessServer()
{
var player = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
// Only Admin can change config.
if (!player.IsAdmin())
{
EconomyScript.Instance.ServerLogger.WriteWarning("A Player without Admin \"{0}\" {1} attempted to access EConfig.", SenderDisplayName, SenderSteamId);
return;
}
MyTexts.LanguageDescription myLanguage;
// These will match with names defined in the RegEx patterm <EconomyScript.EconfigPattern>
switch (ConfigName)
{
#region language
case "language":
if (string.IsNullOrEmpty(Value))
{
myLanguage = MyTexts.Languages[(MyLanguagesEnum)EconomyScript.Instance.ServerConfig.Language];
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "Language: {0} ({1})", myLanguage.Name, myLanguage.FullCultureName);
}
else
{
int intTest;
if (int.TryParse(Value, out intTest))
{
if (MyTexts.Languages.ContainsKey((MyLanguagesEnum)intTest))
{
EconomyScript.Instance.ServerConfig.Language = intTest;
EconomyScript.Instance.SetLanguage();
myLanguage = MyTexts.Languages[(MyLanguagesEnum)intTest];
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "Language updated to: {0} ({1})", myLanguage.Name, myLanguage.FullCultureName);
return;
}
}
foreach (var lang in MyTexts.Languages)
{
if (lang.Value.Name.Equals(Value, StringComparison.InvariantCultureIgnoreCase) ||
lang.Value.CultureName.Equals(Value, StringComparison.InvariantCultureIgnoreCase) ||
lang.Value.FullCultureName.Equals(Value, StringComparison.InvariantCultureIgnoreCase))
{
EconomyScript.Instance.ServerConfig.Language = (int)lang.Value.Id;
EconomyScript.Instance.SetLanguage();
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "Language updated to: {0} ({1})", lang.Value.Name, lang.Value.FullCultureName);
return;
}
}
myLanguage = MyTexts.Languages[(MyLanguagesEnum)EconomyScript.Instance.ServerConfig.Language];
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "Language: {0} ({1})", myLanguage.Name, myLanguage.FullCultureName);
}
break;
#endregion
#region tradenetworkname
case "tradenetworkname":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "TradeNetworkName: {0}", EconomyScript.Instance.ServerConfig.TradeNetworkName);
}
else
{
EconomyScript.Instance.ServerConfig.TradeNetworkName = Value;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "TradeNetworkName updated to: \"{0}\"", EconomyScript.Instance.ServerConfig.TradeNetworkName);
MessageUpdateClient.SendServerConfig(EconomyScript.Instance.ServerConfig);
}
break;
#endregion
#region currencyname
case "currencyname":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "CurrencyName: {0}", EconomyScript.Instance.ServerConfig.CurrencyName);
}
else
{
EconomyScript.Instance.ServerConfig.CurrencyName = Value;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "CurrencyName updated to: \"{0}\"", EconomyScript.Instance.ServerConfig.CurrencyName);
MessageUpdateClient.SendServerConfig(EconomyScript.Instance.ServerConfig);
}
break;
#endregion
#region limitedrange
case "limitedrange":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LimitedRange: {0}", EconomyScript.Instance.ServerConfig.LimitedRange ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
EconomyScript.Instance.ServerConfig.LimitedRange = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LimitedRange updated to: {0}", EconomyScript.Instance.ServerConfig.LimitedRange ? "On" : "Off");
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LimitedRange: {0}", EconomyScript.Instance.ServerConfig.LimitedRange ? "On" : "Off");
}
break;
#endregion
#region limitedsupply
case "limitedsupply":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LimitedSupply: {0}", EconomyScript.Instance.ServerConfig.LimitedSupply ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
EconomyScript.Instance.ServerConfig.LimitedSupply = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LimitedSupply updated to: {0}", EconomyScript.Instance.ServerConfig.LimitedSupply ? "On" : "Off");
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LimitedSupply: {0}", EconomyScript.Instance.ServerConfig.LimitedSupply ? "On" : "Off");
}
break;
#endregion
#region enablelcds
case "enablelcds":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableLcds: {0}", EconomyScript.Instance.ServerConfig.EnableLcds ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
var clearRefresh = EconomyScript.Instance.ServerConfig.EnableLcds && !boolTest;
EconomyScript.Instance.ServerConfig.EnableLcds = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableLcds updated to: {0}", EconomyScript.Instance.ServerConfig.EnableLcds ? "On" : "Off");
if (clearRefresh)
{
LcdManager.BlankLcds();
}
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableLcds: {0}", EconomyScript.Instance.ServerConfig.EnableLcds ? "On" : "Off");
}
break;
#endregion
#region EnableNpcTradezones
case "enablenpctradezones":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableNpcTradezones: {0}", EconomyScript.Instance.ServerConfig.EnableNpcTradezones ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
var clearRefresh = EconomyScript.Instance.ServerConfig.EnableNpcTradezones != boolTest;
EconomyScript.Instance.ServerConfig.EnableNpcTradezones = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableNpcTradezones updated to: {0}", EconomyScript.Instance.ServerConfig.EnableNpcTradezones ? "On" : "Off");
if (clearRefresh)
{
MessageUpdateClient.SendServerTradeZones();
}
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableNpcTradezones: {0}", EconomyScript.Instance.ServerConfig.EnableNpcTradezones ? "On" : "Off");
}
break;
#endregion
#region EnablePlayerTradezones
case "enableplayertradezones":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnablePlayerTradezones: {0}", EconomyScript.Instance.ServerConfig.EnablePlayerTradezones ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
var clearRefresh = EconomyScript.Instance.ServerConfig.EnablePlayerTradezones != boolTest;
EconomyScript.Instance.ServerConfig.EnablePlayerTradezones = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnablePlayerTradezones updated to: {0}", EconomyScript.Instance.ServerConfig.EnablePlayerTradezones ? "On" : "Off");
if (clearRefresh)
{
MessageUpdateClient.SendServerTradeZones();
}
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnablePlayerTradezones: {0}", EconomyScript.Instance.ServerConfig.EnablePlayerTradezones ? "On" : "Off");
}
break;
#endregion
#region EnablePlayerPayments
case "enableplayerpayments":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnablePlayerPayments: {0}", EconomyScript.Instance.ServerConfig.EnablePlayerPayments ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
EconomyScript.Instance.ServerConfig.EnablePlayerPayments = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnablePlayerPayments updated to: {0}", EconomyScript.Instance.ServerConfig.EnablePlayerPayments ? "On" : "Off");
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnablePlayerPayments: {0}", EconomyScript.Instance.ServerConfig.EnablePlayerPayments ? "On" : "Off");
}
break;
#endregion
#region tradetimeout
case "tradetimeout":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "TradeTimeout: {0}", EconomyScript.Instance.ServerConfig.TradeTimeout);
}
else
{
TimeSpan timeTest;
if (TimeSpan.TryParse(Value, out timeTest))
{
EconomyScript.Instance.ServerConfig.TradeTimeout = timeTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "TradeTimeout updated to: {0} ", EconomyScript.Instance.ServerConfig.TradeTimeout);
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "TradeTimeout: {0}", EconomyScript.Instance.ServerConfig.TradeTimeout);
}
break;
#endregion
#region accountexpiry
case "accountexpiry":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "AccountExpiry: {0}", EconomyScript.Instance.ServerConfig.AccountExpiry);
}
else
{
TimeSpan timeTest;
if (TimeSpan.TryParse(Value, out timeTest))
{
EconomyScript.Instance.ServerConfig.AccountExpiry = timeTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "AccountExpiry updated to: {0} ", EconomyScript.Instance.ServerConfig.AccountExpiry);
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "AccountExpiry: {0}", EconomyScript.Instance.ServerConfig.AccountExpiry);
}
break;
#endregion
#region startingbalance
case "startingbalance":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "StartingBalance: {0}", EconomyScript.Instance.ServerConfig.DefaultStartingBalance);
}
else
{
decimal decimalTest;
if (decimal.TryParse(Value, NumberStyles.Any, CultureInfo.InvariantCulture, out decimalTest))
{
// TODO: perhaps we should truncate the value.
if (decimalTest >= 0)
{
EconomyScript.Instance.ServerConfig.DefaultStartingBalance = decimalTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "StartingBalance updated to: {0} ", EconomyScript.Instance.ServerConfig.DefaultStartingBalance);
return;
}
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "StartingBalance: {0}", EconomyScript.Instance.ServerConfig.DefaultStartingBalance);
}
break;
#endregion
#region LicenceMin
case "licencemin":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMin: {0}", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMin);
}
else
{
decimal decimalTest;
if (decimal.TryParse(Value, NumberStyles.Any, CultureInfo.InvariantCulture, out decimalTest))
{
// TODO: perhaps we should truncate the value.
if (decimalTest >= 0)
{
if (EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMax < decimalTest)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMin cannot be more than LicenceMax.");
return;
}
EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMin = decimalTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMin updated to: {0} ", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMin);
return;
}
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMin: {0}", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMin);
}
break;
#endregion
#region LicenceMax
case "licencemax":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMax: {0}", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMax);
}
else
{
decimal decimalTest;
if (decimal.TryParse(Value, NumberStyles.Any, CultureInfo.InvariantCulture, out decimalTest))
{
// TODO: perhaps we should truncate the value.
if (decimalTest >= 0)
{
if (decimalTest < EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMin)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMax cannot be less than LicenceMin.");
return;
}
EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMax = decimalTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMax updated to: {0} ", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMax);
return;
}
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LicenceMax: {0}", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMax);
}
break;
#endregion
#region RelinkRatio
case "relinkratio":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "RelinkRatio: {0}", EconomyScript.Instance.ServerConfig.TradeZoneRelinkRatio);
}
else
{
var numFormat = CultureInfo.CurrentCulture.NumberFormat;
NumberFormatInfo nfi = new NumberFormatInfo()
{
CurrencyDecimalDigits = numFormat.PercentDecimalDigits,
CurrencyDecimalSeparator = numFormat.PercentDecimalSeparator,
CurrencyGroupSeparator = numFormat.PercentGroupSeparator,
CurrencyGroupSizes = numFormat.PercentGroupSizes,
CurrencyNegativePattern = numFormat.PercentNegativePattern,
CurrencyPositivePattern = numFormat.PercentPositivePattern,
CurrencySymbol = numFormat.PercentSymbol
};
decimal decimalTest;
if (decimal.TryParse(Value, NumberStyles.Any, CultureInfo.InvariantCulture, out decimalTest))
{
// TODO: perhaps we should truncate the value.
if (decimalTest >= 0)
{
EconomyScript.Instance.ServerConfig.TradeZoneRelinkRatio = decimalTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "RelinkRatio updated to: {0:P} ", EconomyScript.Instance.ServerConfig.TradeZoneRelinkRatio);
return;
}
}
else if (decimal.TryParse(Value, NumberStyles.Currency, nfi, out decimalTest))
{
// TODO: perhaps we should truncate the value.
if (decimalTest >= 0)
{
EconomyScript.Instance.ServerConfig.TradeZoneRelinkRatio = decimalTest / 100;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "RelinkRatio updated to: {0:P} ", EconomyScript.Instance.ServerConfig.TradeZoneRelinkRatio);
return;
}
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "RelinkRatio: {0:P}", EconomyScript.Instance.ServerConfig.TradeZoneRelinkRatio);
}
break;
#endregion
#region MaximumPlayerZones
case "maximumplayerzones":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "MaximumPlayerZones: {0}", EconomyScript.Instance.ServerConfig.MaximumPlayerTradeZones);
}
else
{
int intTest;
if (int.TryParse(Value, out intTest))
{
if (intTest >= 0)
{
EconomyScript.Instance.ServerConfig.MaximumPlayerTradeZones = intTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "MaximumPlayerZones updated to: {0} ", EconomyScript.Instance.ServerConfig.MaximumPlayerTradeZones);
return;
}
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "TradeZoneLicence: {0}", EconomyScript.Instance.ServerConfig.MaximumPlayerTradeZones);
}
break;
#endregion
#region pricescaling
case "pricescaling":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "PriceScaling: {0}", EconomyScript.Instance.ServerConfig.PriceScaling ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
EconomyScript.Instance.ServerConfig.PriceScaling = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "PriceScaling updated to: {0}", EconomyScript.Instance.ServerConfig.PriceScaling ? "On" : "Off");
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "PriceScaling: {0}", EconomyScript.Instance.ServerConfig.PriceScaling ? "On" : "Off");
}
break;
#endregion
#region shiptrading
case "shiptrading":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "ShipTrading: {0}", EconomyScript.Instance.ServerConfig.ShipTrading ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
EconomyScript.Instance.ServerConfig.ShipTrading = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "ShipTrading updated to: {0}", EconomyScript.Instance.ServerConfig.ShipTrading ? "On" : "Off");
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "ShipTrading: {0}", EconomyScript.Instance.ServerConfig.ShipTrading ? "On" : "Off");
}
break;
#endregion
#region MinimumLcdDisplayInterval
case "lcddisplayinterval":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LcdDisplayInterval: {0}", EconomyScript.Instance.ServerConfig.MinimumLcdDisplayInterval);
}
else
{
decimal decimalTest;
if (decimal.TryParse(Value, NumberStyles.Any, CultureInfo.InvariantCulture, out decimalTest))
{
// TODO: perhaps we should truncate the value.
if (decimalTest >= 0)
{
if (decimalTest < 1)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LcdDisplayInterval cannot be less than 1 second.");
return;
}
if (decimalTest > 1000) // no particular reason for 1000, apart from it been a reasonable limit.
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LcdDisplayInterval cannot be more than 1000 second.");
return;
}
EconomyScript.Instance.ServerConfig.MinimumLcdDisplayInterval = decimalTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LcdDisplayInterval updated to: {0} seconds", EconomyScript.Instance.ServerConfig.MinimumLcdDisplayInterval);
return;
}
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "LcdDisplayInterval: {0} seconds", EconomyScript.Instance.ServerConfig.MinimumLcdDisplayInterval);
}
break;
#endregion
#region EnableMissions
case "enablemissions":
if (string.IsNullOrEmpty(Value))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableMissions: {0}", EconomyScript.Instance.ServerConfig.EnableMissions ? "On" : "Off");
}
else
{
bool boolTest;
if (Value.TryWordParseBool(out boolTest))
{
EconomyScript.Instance.ServerConfig.EnableMissions = boolTest;
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableMissions updated to: {0}", EconomyScript.Instance.ServerConfig.EnableMissions ? "On" : "Off");
MessageUpdateClient.SendServerConfig(EconomyScript.Instance.ServerConfig);
return;
}
MessageClientTextMessage.SendMessage(SenderSteamId, "ECONFIG", "EnableMissions: {0}", EconomyScript.Instance.ServerConfig.EnableMissions ? "On" : "Off");
}
break;
#endregion
#region default
default:
var msg = new StringBuilder();
myLanguage = MyTexts.Languages[(MyLanguagesEnum)EconomyScript.Instance.ServerConfig.Language];
msg.AppendFormat("Language: {0} ({1})\r\n", myLanguage.Name, myLanguage.FullCultureName);
msg.AppendFormat("TradeNetworkName: \"{0}\"\r\n", EconomyScript.Instance.ServerConfig.TradeNetworkName);
msg.AppendFormat("LimitedRange: {0}\r\n", EconomyScript.Instance.ServerConfig.LimitedRange ? "On" : "Off");
msg.AppendFormat("LimitedSupply: {0}\r\n", EconomyScript.Instance.ServerConfig.LimitedSupply ? "On" : "Off");
msg.AppendFormat("TradeTimeout: {0} (days.hours:mins:secs)\r\n", EconomyScript.Instance.ServerConfig.TradeTimeout);
msg.AppendFormat("StartingBalance: {0:#,#.######}\r\n", EconomyScript.Instance.ServerConfig.DefaultStartingBalance);
msg.AppendFormat("CurrencyName: \"{0}\"\r\n", EconomyScript.Instance.ServerConfig.CurrencyName);
msg.AppendFormat("AccountExpiry: {0} (days.hours:mins:secs)\r\n", EconomyScript.Instance.ServerConfig.AccountExpiry);
msg.AppendFormat("EnableLcds: {0}\r\n", EconomyScript.Instance.ServerConfig.EnableLcds ? "On" : "Off");
msg.AppendFormat("EnableNpcTradezones: {0}\r\n", EconomyScript.Instance.ServerConfig.EnableNpcTradezones ? "On" : "Off");
msg.AppendFormat("PriceScaling: {0}\r\n", EconomyScript.Instance.ServerConfig.PriceScaling ? "On" : "Off");
msg.AppendFormat("ShipTrading: {0}\r\n", EconomyScript.Instance.ServerConfig.ShipTrading ? "On" : "Off");
msg.AppendFormat("LcdDisplayInterval: {0:#,#.######} seconds\r\n", EconomyScript.Instance.ServerConfig.MinimumLcdDisplayInterval);
msg.AppendLine();
msg.AppendLine("--- Player Tradezones ---");
msg.AppendFormat("EnablePlayerTradezones: {0}\r\n", EconomyScript.Instance.ServerConfig.EnablePlayerTradezones ? "On" : "Off");
msg.AppendFormat("EnablePlayerPayments: {0}\r\n", EconomyScript.Instance.ServerConfig.EnablePlayerPayments ? "On" : "Off");
msg.AppendFormat("LicenceMin: {0:#,#.######} (at {1:#,#.######}m)\r\n", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMin, EconomyScript.Instance.ServerConfig.TradeZoneMinRadius);
msg.AppendFormat("LicenceMax: {0:#,#.######} (at {1:#,#.######}m)\r\n", EconomyScript.Instance.ServerConfig.TradeZoneLicenceCostMax, EconomyScript.Instance.ServerConfig.TradeZoneMaxRadius);
msg.AppendFormat("RelinkRatio: {0:P}\r\n", EconomyScript.Instance.ServerConfig.TradeZoneRelinkRatio);
msg.AppendFormat("MaximumPlayerZones: {0}\r\n", EconomyScript.Instance.ServerConfig.MaximumPlayerTradeZones);
// Not yet ready for general use.
//msg.AppendFormat("EnableMissions: {0}\r\n", EconomyScript.Instance.ServerConfig.EnableMissions ? "On" : "Off");
MessageClientDialogMessage.SendMessage(SenderSteamId, "ECONFIG", " ", msg.ToString());
break;
#endregion
}
}
public override void ProcessServer()
{
// update our own timestamp here
AccountManager.UpdateLastSeen(SenderSteamId, SenderLanguage);
EconomyScript.Instance.ServerLogger.WriteVerbose("Price List Request for from '{0}'", SenderSteamId);
var player = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
var character = player.GetCharacter();
if (character == null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "You are dead. You get market items values while dead.");
return;
}
List <MarketStruct> markets;
if (string.IsNullOrEmpty(FindMarket))
{
var position = ((IMyEntity)character).WorldMatrix.Translation;
markets = MarketManager.FindMarketsFromLocation(position);
}
else
{
markets = MarketManager.FindMarketsFromName(FindMarket);
}
if (markets.Count == 0)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "Sorry, your are not in range of any markets!");
return;
}
// TODO: combine multiple markets to list best Buy and Sell prices that isn't blacklisted.
var market = markets.FirstOrDefault();
if (market == null) //hmmm looks like market name parameter checking was started but never done
{
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "That market does not exist.");
return; //as I understand it this would only trigger if no markets are defined?
//in which case should it read no markets exist? but in that case
// wont the count check above halt execution before this if statement???
// remove these comments once read :)
}
string reply = null;
MyAPIGateway.Parallel.StartBackground(delegate()
// Background processing occurs within this block.
{
try
{
bool showAll = !ShowOre && !ShowIngot && !ShowComponent && !ShowAmmo && !ShowTools && !ShowGasses;
var orderedList = new Dictionary <MarketItemStruct, string>();
foreach (var marketItem in market.MarketItems)
{
if (marketItem.IsBlacklisted)
{
continue;
}
MyObjectBuilderType result;
if (MyObjectBuilderType.TryParse(marketItem.TypeId, out result))
{
var id = new MyDefinitionId(result, marketItem.SubtypeName);
var content = Support.ProducedType(id);
// Cannot check the Type of the item, without having to use MyObjectBuilderSerializer.CreateNewObject().
if (showAll ||
(ShowOre && content is MyObjectBuilder_Ore) ||
(ShowIngot && content is MyObjectBuilder_Ingot) ||
(ShowComponent && content is MyObjectBuilder_Component) ||
(ShowAmmo && content is MyObjectBuilder_AmmoMagazine) ||
(ShowTools && content is MyObjectBuilder_PhysicalGunObject) || // guns, welders, hand drills, grinders.
(ShowGasses && content is MyObjectBuilder_GasContainerObject) || // aka gas bottle.
(ShowGasses && content is MyObjectBuilder_GasProperties))
// Type check here allows mods that inherit from the same type to also appear in the lists.
{
var definition = MyDefinitionManager.Static.GetDefinition(marketItem.TypeId, marketItem.SubtypeName);
var name = definition == null ? marketItem.SubtypeName : definition.GetDisplayName();
orderedList.Add(marketItem, name);
}
}
}
orderedList = orderedList.OrderBy(kvp => kvp.Value).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
var str = new SeTextBuilder();
str.AppendLine("Market: {0}\r\n", market.DisplayName);
str.AddLeftTrim(550, "Item");
str.AddRightText(650, "Buy at");
str.AddRightText(850, "Sell at");
str.AppendLine();
foreach (var kvp in orderedList)
{
decimal showBuy = kvp.Key.BuyPrice;
decimal showSell = kvp.Key.SellPrice;
if ((EconomyScript.Instance.ServerConfig.PriceScaling) && (market.MarketId == EconomyConsts.NpcMerchantId))
{
showBuy = EconDataManager.PriceAdjust(kvp.Key.BuyPrice, kvp.Key.Quantity, PricingBias.Buy);
showSell = EconDataManager.PriceAdjust(kvp.Key.SellPrice, kvp.Key.Quantity, PricingBias.Sell);
}
// TODO: formatting of numbers, and currency name.
str.AddLeftTrim(550, kvp.Value);
str.AddRightText(650, showBuy.ToString("0.00", EconomyScript.ServerCulture));
str.AddRightText(850, showSell.ToString("0.00", EconomyScript.ServerCulture));
str.AppendLine();
}
reply = str.ToString();
}
catch (Exception ex)
{
EconomyScript.Instance.ServerLogger.WriteException(ex);
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "Failed and died. Please contact the administrator.");
}
}, delegate()
// when the background processing is finished, this block will run foreground.
{
if (reply != null)
{
try
{
MessageClientDialogMessage.SendMessage(SenderSteamId, "PRICELIST", " ", reply);
}
catch (Exception ex)
{
EconomyScript.Instance.ServerLogger.WriteException(ex);
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "Failed and died. Please contact the administrator.");
}
}
});
}
public override void ProcessServer()
{
// update our own timestamp here
AccountManager.UpdateLastSeen(SenderSteamId, SenderLanguage);
EconomyScript.Instance.ServerLogger.WriteVerbose("Price List Request for from '{0}'", SenderSteamId);
var player = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
var character = player.GetCharacter();
if (character == null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "You are dead. You get market items values while dead.");
return;
}
var position = ((IMyEntity)character).WorldMatrix.Translation;
var markets = MarketManager.FindMarketsFromLocation(position);
if (markets.Count == 0)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "Sorry, your are not in range of any markets!");
return;
}
// TODO: combine multiple markets to list best Buy and Sell prices that isn't blacklisted.
var market = markets.FirstOrDefault();
if (market == null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "That market does not exist.");
return;
}
string reply = null;
MyAPIGateway.Parallel.StartBackground(delegate()
// Background processing occurs within this block.
{
try
{
bool showAll = !ShowOre && !ShowIngot && !ShowComponent && !ShowAmmo && !ShowTools;
var orderedList = new Dictionary <MarketItemStruct, string>();
foreach (var marketItem in market.MarketItems)
{
if (marketItem.IsBlacklisted)
{
continue;
}
MyObjectBuilderType result;
if (MyObjectBuilderType.TryParse(marketItem.TypeId, out result))
{
var id = new MyDefinitionId(result, marketItem.SubtypeName);
var content = Support.ProducedType(id);
// Cannot check the Type of the item, without having to use MyObjectBuilderSerializer.CreateNewObject().
if (showAll ||
(ShowOre && content is MyObjectBuilder_Ore) ||
(ShowIngot && content is MyObjectBuilder_Ingot) ||
(ShowComponent && content is MyObjectBuilder_Component) ||
(ShowAmmo && content is MyObjectBuilder_AmmoMagazine) ||
(ShowTools && content is MyObjectBuilder_PhysicalGunObject) ||
(ShowTools && content is MyObjectBuilder_GasContainerObject)) // Type check here allows mods that inherit from the same type to also appear in the lists.
{
var definition = MyDefinitionManager.Static.GetDefinition(marketItem.TypeId, marketItem.SubtypeName);
var name = definition == null ? marketItem.SubtypeName : definition.GetDisplayName();
orderedList.Add(marketItem, name);
}
}
}
orderedList = orderedList.OrderBy(kvp => kvp.Value).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
var str = new SeTextBuilder();
str.AppendLine("Market: {0}\r\n", market.DisplayName);
str.AddLeftTrim(550, "Item");
str.AddRightText(650, "Buy at");
str.AddRightText(850, "Sell at");
str.AppendLine();
foreach (var kvp in orderedList)
{
// TODO: formatting of numbers, and currency name.
str.AddLeftTrim(550, kvp.Value);
str.AddRightText(650, kvp.Key.BuyPrice.ToString("0.00", EconomyScript.ServerCulture));
str.AddRightText(850, kvp.Key.SellPrice.ToString("0.00", EconomyScript.ServerCulture));
str.AppendLine();
}
reply = str.ToString();
}
catch (Exception ex)
{
EconomyScript.Instance.ServerLogger.WriteException(ex);
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "Failed and died. Please contact the administrator.");
}
}, delegate()
// when the background processing is finished, this block will run foreground.
{
if (reply != null)
{
try
{
MessageClientDialogMessage.SendMessage(SenderSteamId, "PRICELIST", " ", reply);
}
catch (Exception ex)
{
EconomyScript.Instance.ServerLogger.WriteException(ex);
MessageClientTextMessage.SendMessage(SenderSteamId, "PRICELIST", "Failed and died. Please contact the administrator.");
}
}
});
}
public override void ProcessServer()
{
// update our own timestamp here
AccountManager.UpdateLastSeen(SenderSteamId, SenderLanguage);
EconomyScript.Instance.ServerLogger.WriteVerbose("Worth Request for {0} from '{1}'", EntityId, SenderSteamId);
var player = MyAPIGateway.Players.FindPlayerBySteamId(SenderSteamId);
var character = player.GetCharacter();
if (character == null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "WORTH", "You are dead. You get market items values while dead.");
return;
}
var position = ((IMyEntity)character).WorldMatrix.Translation;
var markets = MarketManager.FindMarketsFromLocation(position);
// TODO: find market with best Buy price that isn't blacklisted.
var market = markets.FirstOrDefault();
string marketDetail = null;
if (market == null)
{
market = EconomyScript.Instance.Data.Markets.FirstOrDefault(m => m.MarketId == EconomyConsts.NpcMerchantId);
if (market != null)
{
marketDetail = string.Format("No markets in range, using default market '{0}' for appraisal.", market.DisplayName);
}
}
if (market == null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "WORTH", "That market does not exist.");
return;
}
if (marketDetail == null)
{
marketDetail = string.Format("Using market '{0}' for appraisal.", market.DisplayName);
}
if (!MyAPIGateway.Entities.EntityExists(EntityId))
{
MessageClientTextMessage.SendMessage(SenderSteamId, "WORTH", "Sorry, the entity no longer exists!");
return;
}
var selectedShip = MyAPIGateway.Entities.GetEntityById(EntityId) as IMyCubeGrid;
if (selectedShip == null)
{
MessageClientTextMessage.SendMessage(SenderSteamId, "WORTH", "Sorry, the entity no longer exists!");
return;
}
int terminalBlocks = 0;
int armorBlocks = 0;
decimal shipValue = 0;
decimal inventoryValue = 0;
int gridCount = 0;
var gridComponents = new Dictionary <MyDefinitionId, decimal>();
var inventoryComponents = new Dictionary <MyDefinitionId, decimal>();
MessageClientTextMessage.SendMessage(SenderSteamId, "WORTH", "Calculating the worth...");
MyAPIGateway.Parallel.StartBackground(delegate()
// Background processing occurs within this block.
{
EconomyScript.Instance.ServerLogger.WriteInfo("Worth:background start");
try
{
var grids = selectedShip.GetAttachedGrids(AttachedGrids.Static);
gridCount = grids.Count;
foreach (var grid in grids)
{
var blocks = new List <IMySlimBlock>();
grid.GetBlocks(blocks);
foreach (var block in blocks)
{
MyCubeBlockDefinition blockDefintion;
if (block.FatBlock == null)
{
armorBlocks++;
blockDefintion = MyDefinitionManager.Static.GetCubeBlockDefinition(block.GetObjectBuilder());
}
else
{
terminalBlocks++;
blockDefintion = MyDefinitionManager.Static.GetCubeBlockDefinition(block.FatBlock.BlockDefinition);
}
//EconomyScript.Instance.ServerLogger.Write("Cube Worth '{0}' '{1}' {2} {3}.", blockDefintion.Id.TypeId, blockDefintion.Id.SubtypeName, block.BuildIntegrity, block.BuildLevelRatio);
#region Go through component List based on construction level.
foreach (var component in blockDefintion.Components)
{
//EconomyScript.Instance.ServerLogger.Write("Component Worth '{0}' '{1}' x {2}.", component.Definition.Id.TypeId, component.Definition.Id.SubtypeName, component.Count);
if (!gridComponents.ContainsKey(component.Definition.Id))
{
gridComponents.Add(component.Definition.Id, 0);
}
gridComponents[component.Definition.Id] += component.Count;
}
// This will subtract off components missing from a partially built cube.
// This also includes the Construction Inventory.
var missingComponents = new Dictionary <string, int>();
block.GetMissingComponents(missingComponents);
foreach (var kvp in missingComponents)
{
var definitionid = new MyDefinitionId(typeof(MyObjectBuilder_Component), kvp.Key);
gridComponents[definitionid] -= kvp.Value;
}
#endregion
if (block.FatBlock != null)
{
var cube = (MyEntity)block.FatBlock;
#region Go through Gasses for tanks and cockpits.
var tank = cube as IMyGasTank;
var gasTankDefintion = blockDefintion as MyGasTankDefinition;
if (gasTankDefintion != null && tank != null)
{
decimal volume = (decimal)gasTankDefintion.Capacity * (decimal)tank.FilledRatio;
if (!inventoryComponents.ContainsKey(gasTankDefintion.StoredGasId))
{
inventoryComponents.Add(gasTankDefintion.StoredGasId, 0);
}
inventoryComponents[gasTankDefintion.StoredGasId] += volume;
//MessageClientTextMessage.SendMessage(SenderSteamId, "GAS tank", "{0} detected {1}", gasTankDefintion.StoredGasId, volume);
}
// Check through Cockpits.
var cockpit = cube as Sandbox.Game.Entities.MyCockpit; // For some reason, the o2 is on the MyCockpit Class. There is no Interface.
if (cockpit != null)
{
// Hardcoded, because Oxygen and Hydrogen do not have available defintions.
var oxygenDefintion = new MyDefinitionId(typeof(MyObjectBuilder_GasProperties), "Oxygen");
if (!inventoryComponents.ContainsKey(oxygenDefintion))
{
inventoryComponents.Add(oxygenDefintion, 0);
}
inventoryComponents[oxygenDefintion] += (decimal)cockpit.OxygenAmount;
//MessageClientTextMessage.SendMessage(SenderSteamId, "COCKPIT tank", "{0} detected {1}", null, cockpit.OxygenAmount);
}
#endregion
#region Go through all other Inventories for components/items.
// Inventory check based on normal game access.
var relation = block.FatBlock.GetUserRelationToOwner(player.IdentityId);
if (relation != MyRelationsBetweenPlayerAndBlock.Enemies &&
relation != MyRelationsBetweenPlayerAndBlock.Neutral)
{
for (var i = 0; i < cube.InventoryCount; i++)
{
var inventory = cube.GetInventory(i);
var list = inventory.GetItems();
foreach (var item in list)
{
var id = item.Content.GetId();
if (!inventoryComponents.ContainsKey(id))
{
inventoryComponents.Add(id, 0);
}
inventoryComponents[id] += (decimal)item.Amount;
// Go through Gas bottles.
var gasContainer = item.Content as MyObjectBuilder_GasContainerObject;
if (gasContainer != null)
{
var defintion = (MyOxygenContainerDefinition)MyDefinitionManager.Static.GetPhysicalItemDefinition(item.Content.GetId());
decimal volume = (decimal)defintion.Capacity * (decimal)gasContainer.GasLevel;
if (!inventoryComponents.ContainsKey(defintion.StoredGasId))
{
inventoryComponents.Add(defintion.StoredGasId, 0);
}
inventoryComponents[defintion.StoredGasId] += volume;
//MessageClientTextMessage.SendMessage(SenderSteamId, "GAS bottle", "{0} detected {1}", defintion.StoredGasId, volume);
}
}
}
}
#endregion
}
}
}
shipValue += SumComponents(market, gridComponents);
inventoryValue += SumComponents(market, inventoryComponents);
}
catch (Exception ex)
{
EconomyScript.Instance.ServerLogger.WriteException(ex);
MessageClientTextMessage.SendMessage(SenderSteamId, "WORTH", "Failed and died. Please contact the administrator.");
}
EconomyScript.Instance.ServerLogger.WriteInfo("Worth:background end");
}, delegate()
// when the background processing is finished, this block will run foreground.
{
EconomyScript.Instance.ServerLogger.WriteInfo("Worth:foreground");
try
{
var str = new StringBuilder();
//foreach (var kvp in gridComponents)
//{
// MyDefinitionBase definition = null;
// MyDefinitionManager.Static.TryGetDefinition(kvp.Key, out definition);
// str.AppendFormat("'{0}' x {1}.\r\n", definition == null ? kvp.Key.SubtypeName : definition.GetDisplayName(), kvp.Value);
//}
//foreach (var kvp in inventoryComponents)
//{
// MyDefinitionBase definition = null;
// MyDefinitionManager.Static.TryGetDefinition(kvp.Key, out definition);
// str.AppendFormat("'{0}' x {1}.\r\n", definition == null ? kvp.Key.SubtypeName : definition.GetDisplayName(), kvp.Value);
//}
//var prefix = string.Format("{0:#,##0.00000}", totalValue);
var shipSale = ShipManager.CheckSellOrder(selectedShip.EntityId);
str.AppendLine(marketDetail);
str.AppendFormat("{0}: {1}\r\n", selectedShip.IsStatic ? "Station" : selectedShip.GridSizeEnum.ToString() + " Ship", selectedShip.DisplayName);
str.AppendFormat("Grids={2}\r\nArmor Blocks={0}\r\nTerminal Blocks={1}\r\n", armorBlocks, terminalBlocks, gridCount);
str.AppendLine("-----------------------------------");
str.AppendFormat("Ship Value: {0:#,##0.00000} {1}.\r\n", shipValue, EconomyScript.Instance.ServerConfig.CurrencyName);
str.AppendFormat("Inventory Value: {0:#,##0.00000} {1}.\r\n", inventoryValue, EconomyScript.Instance.ServerConfig.CurrencyName);
str.AppendFormat("Final Value: {0:#,##0.00000} {1}.\r\n", shipValue + inventoryValue, EconomyScript.Instance.ServerConfig.CurrencyName);
str.AppendLine("-----------------------------------");
if (shipSale != 0)
{
str.AppendFormat("Sale Price: {0:#,##0.00000} {1}.\r\n", shipSale, EconomyScript.Instance.ServerConfig.CurrencyName);
}
else
{
str.AppendLine("Sale Price: Not for Sale.\r\n");
}
MessageClientDialogMessage.SendMessage(SenderSteamId, "WORTH", selectedShip.DisplayName, str.ToString());
}
catch (Exception ex)
{
EconomyScript.Instance.ServerLogger.WriteException(ex);
MessageClientTextMessage.SendMessage(SenderSteamId, "WORTH", "Failed and died. Please contact the administrator.");
}
});
}