public TierName[] GetRollTiers(GamePlayer player, Random random)
{
var shopLength = player.Shop.Length;
var resultTiers = new TierName[shopLength];
var tierChances = TierInfo.GetChances(player.Lvl);
for (var i = 0; i < shopLength; i++)
{
var randomNum = random.Next(1, 101);
var temp = 0;
for (var j = 0; j < tierChances.Length; j++)
{
var tierChance = tierChances[j];
if (randomNum <= tierChance + temp)
{
while (
this[(TierName)j].Count -
resultTiers.Count(item => (int)item == j) == 0
)
{
j--;
}
resultTiers[i] = (TierName)j;
break;
}
temp += tierChance;
}
}
return(resultTiers);
}
public WeightInfo(EntityDefault lotteryItem, CategoryFlags categoryFlags, TierInfo tier, double weight)
{
this.lotteryItem = lotteryItem;
this.categoryFlags = categoryFlags;
this.tier = tier;
this.weight = weight;
}
private readonly RateLimiter _privateApiRateLimiter; // Nullable.
/// <summary>
/// Initializes a new instance of the <see cref="KrakenClient"/> class.
/// </summary>
/// <param name="apiKey">Key required to make private queries to the API.</param>
/// <param name="privateKey">Secret required to sign private messages.</param>
/// <param name="rateLimit">
/// Used to enable API call rate limiter conforming to Kraken rules. To disable, use <see cref="RateLimit.None"/>.
/// </param>
public KrakenClient(
string apiUrl,
string apiKey,
string privateKey,
RateLimit rateLimit = RateLimit.None)
{
if (apiKey == null)
{
throw new ArgumentNullException(nameof(apiKey));
}
if (privateKey == null)
{
throw new ArgumentNullException(nameof(privateKey));
}
ApiKey = apiKey;
PrivateKey = privateKey;
RateLimit = rateLimit;
TierInfo info = null;
if (TierInfo.TryGetValue(rateLimit, out info))
{
_privateApiRateLimiter = new RateLimiter(info.Limit, info.DecreaseTime, new Stopwatch());
// If private rate limiter enabled, also enable public rate limiter.
_publicApiRateLimiter = new RateLimiter(20, TimeSpan.FromSeconds(1), new Stopwatch());
}
_httpClient.BaseAddress = new Uri(apiUrl);
_sha512PrivateKey = new HMACSHA512(Convert.FromBase64String(privateKey));
}
public ShipPart SellBagItem(int bagIndex)
{
var shipPart = Bag[bagIndex];
Bag[bagIndex] = null;
ChangeMoney(TierInfo.Get(shipPart.TierName).Cost *(shipPart.Rank == 1 ? 1 : 3));
return(shipPart);
}
public ShipPart BuyShipPart(int shopItemIndex)
{
var shipPart = Shop[shopItemIndex];
ChangeMoney(-TierInfo.Get(shipPart.TierName).Cost);
Shop[shopItemIndex] = null;
return(shipPart);
}
public int GetCliloc(int points)
{
for (int i = m_Tiers.Length - 1; i > 0; i--)
{
TierInfo tier = m_Tiers[i];
if (points >= tier.MinPoints)
{
return(tier.Cliloc);
}
}
return(m_Tiers[0].Cliloc);
}
public bool CanBuyShipPart(int shopIndex)
{
//todo T2 GUNS checking
var hasShopItem = Shop[shopIndex] != null;
if (hasShopItem)
{
var enoughMoney = Money >= TierInfo.Get(Shop[shopIndex].TierName).Cost;
var hasBagPlace = Bag.Count(
component => component == null
) > 0;
return(enoughMoney && hasBagPlace);
}
return(false);
}
public void Generate(IEnumerable <ShipPart> components, Random random)
{
Clear();
foreach (TierName tier in Enum.GetValues(typeof(TierName)))
{
Add(tier, new T());
}
foreach (var component in components)
{
for (var i = 0; i < TierInfo.Get(component.TierName).Count; i++)
{
this[component.TierName].Insert(
random.Next(this[component.TierName].Count + 1),
component
);
}
}
}
public LotteryItem(IEntityDefaultReader entityDefaultReader)
{
_entityDefaultReader = entityDefaultReader;
if (_weights == null)
{
_weights = Db.Query().CommandText("select * from lotteryitemweights")
.Execute()
.Select(r =>
{
var lotteryDefinition = r.GetValue <int>("lotterydefinition");
var categoryFlags = r.GetValue <CategoryFlags>("categoryflags");
var tierType = (TierType)r.GetValue <int>("tiertype");
var tierLevel = r.GetValue <int>("tierlevel");
var weight = r.GetValue <double>("weight");
var tier = new TierInfo(tierType, tierLevel);
return(new WeightInfo(EntityDefault.Get(lotteryDefinition), categoryFlags, tier, weight));
}).ToLookup(i => i.lotteryItem);
}
}
public ShipPart AddShipPartToShipAndSell(Ship ship, int bagIndex)
{
var shipPart = Bag[bagIndex];
if (shipPart == ship.Parts[shipPart.Type])
{
var indexesToCreateT2 = IndexesToCreateT2(shipPart);
if (indexesToCreateT2 != null)
{
if (indexesToCreateT2.Count == 2)
{
foreach (var i in indexesToCreateT2)
{
Bag[i] = null;
}
shipPart = ShipPartInfo.T2Rank[shipPart.Name];
ship.ChangeComponent(shipPart);
return(shipPart);
}
}
else
{
return(null);
}
}
else
{
Bag[bagIndex] = null;
var oldShipPart = ship.ChangeComponent(shipPart);
if (oldShipPart != null)
{
ChangeMoney(TierInfo.Get(oldShipPart.TierName).Cost *(oldShipPart.Rank == 1 ? 1 : 3));
}
}
return(shipPart);
}
/// <summary>
/// Load filesystem information from the database.
/// </summary>
private void LoadFilesystems()
{
bool changed = false;
lock (SyncLock)
{
try
{
List <FilesystemTierEnum> tiers = FilesystemTierEnum.GetAll();
// sorted by enum values
tiers.Sort((tier1, tier2) => tier1.Enum.CompareTo(tier2.Enum));
_tierInfo = new TierInfo();
foreach (FilesystemTierEnum tier in tiers)
{
_tierInfo.Add(tier, new List <ServerFilesystemInfo>());
}
using (IReadContext read = _store.OpenReadContext())
{
IFilesystemEntityBroker filesystemSelect = read.GetBroker <IFilesystemEntityBroker>();
FilesystemSelectCriteria criteria = new FilesystemSelectCriteria();
IList <Filesystem> filesystemList = filesystemSelect.Find(criteria);
foreach (Filesystem filesystem in filesystemList)
{
if (_filesystemList.ContainsKey(filesystem.Key))
{
if ((filesystem.HighWatermark != _filesystemList[filesystem.Key].Filesystem.HighWatermark) ||
(filesystem.LowWatermark != _filesystemList[filesystem.Key].Filesystem.LowWatermark))
{
Platform.Log(LogLevel.Info, "Watermarks have changed for filesystem {0}, Low: {1}, High: {2}",
filesystem.Description, filesystem.LowWatermark, filesystem.HighWatermark);
}
_filesystemList[filesystem.Key].Filesystem = filesystem;
_tierInfo[filesystem.FilesystemTierEnum].Add(_filesystemList[filesystem.Key]);
}
else
{
ServerFilesystemInfo info = new ServerFilesystemInfo(filesystem);
_filesystemList.Add(filesystem.Key, info);
_tierInfo[filesystem.FilesystemTierEnum].Add(info);
info.LoadFreeSpace();
changed = true;
}
}
}
if (changed && _changedListener != null)
{
EventsHelper.Fire(_changedListener, this, new FilesystemChangedEventArgs(this));
}
}
catch (Exception ex)
{
Platform.Log(LogLevel.Error, ex,
"Exception has occurred while updating the filesystem list from the datbase. Retry later");
}
}
}
