//only call if win
public int levelingUp()
{
Leveling lvl = new Leveling(level, xp, xpGained);
//check win
Random randy = new Random();
xpGained = randy.Next(50, 100);
if (xp + xpGained = 200)
{
Console.WriteLine("You Leveled UP!!!!!");
xp += xpGained;
xpGained = 0;
level += 1;
if (level > 10)
{
Player player = new Player();
player.DamageMod = 10;
player.HealthMod = 25;
player.BaseHealth += player.HealthMod;
player.BaseDamage += player.DamageMod;
level = 1;
for (int j = 0; j <= mastery; j++)
{
mastery += 1;
}
}
}
public static Leveling LoadLeveling(string text)
{
var leveling = new Leveling();
leveling.LoadFromXmlText(text);
return(leveling);
}
void GiveXPToPartyOverTime()
{
//Gives all party members the XP earned in their last battle
for (int i = 0; i < _partyContainer.PartyMembers.Count; i++)
{
Leveling.OnExperienceIncreaseOverTime(_partyContainer.PartyMembers[i], CombatRewards.XPEarned);
}
}
public void ValidateForEXPAsync_NullGuild_ThrowsException()
{
var message = CreateMockUserMessage();
AsyncTestDelegate act = () => Leveling.ValidateForEXPAsync(message, null);
Assert.That(act, Throws.TypeOf <ArgumentException>());
}
void FillXpBar()
{
_levelBar.fillAmount = _partyMember.CurrentXP / _partyMember.RequiredXP;
if (_partyMember.CurrentXP >= _partyMember.RequiredXP)
{
Leveling.OnLevelUp(_partyMember);
_levelBar.fillAmount = 0;
}
}
public void ValidateForEXPAsync_ExemptChannel_ThrowsException()
{
var message = CreateMockUserMessage();
Guild.XP.ExemptChannels = new ulong[] { 123 };
AsyncTestDelegate act = () => Leveling.ValidateForEXPAsync(message, null);
Assert.That(act, Throws.TypeOf <InvalidOperationException>());
}
void Start()
{
lving = GetComponent <Leveling>();
uiController = UIController.instance;
weaponID = WeaponType.None;
Initialize_HMSP(100, .4f, 50, .25f, 50f, 1.9f);
Initialize_Attributes(0, 10f, 10f, 10f, 10f, 10f, 0f, 1.5f);
onStatsChangeCallback += CalCombatStats;
}
public void ValidateForEXPAsync_UserInCooldown_ThrowsException()
{
var message = CreateMockUserMessage();
GuildUser.XP.LastXPMsg = DateTime.Now;
AsyncTestDelegate act = () => Leveling.ValidateForEXPAsync(message, Guild);
Assert.That(act, Throws.TypeOf <InvalidOperationException>());
}
private async Task HandleReactionAsync(Cacheable <IUserMessage, ulong> Message, ISocketMessageChannel Channel, SocketReaction Reaction)
{
var User = (SocketGuildUser)Reaction.User;
if (User.IsBot)
{
return;
}
Leveling.UserAddedReaction(User, Reaction);
await Task.CompletedTask;
}
public BattlingShip(MasterDataRoot masterData, RawShipInBattle raw)
{
Info = masterData.ShipInfos[raw.Id];
Leveling = new Leveling(raw.Level);
HP = raw.HP;
Slots = raw.Equipment.Select(x => new ImplicitSlot(masterData.EquipmentInfos[x])).ToBindable();
Firepower = new ShipMordenizationStatus(raw.Firepower, raw.Firepower + Slots.Sum(x => x.Equipment.Info?.Firepower ?? 0));
Torpedo = new ShipMordenizationStatus(raw.Torpedo, raw.Torpedo + Slots.Sum(x => x.Equipment.Info?.Torpedo ?? 0));
AntiAir = new ShipMordenizationStatus(raw.AntiAir, raw.AntiAir + Slots.Sum(x => x.Equipment.Info?.AntiAir ?? 0));
Armor = new ShipMordenizationStatus(raw.Armor, raw.Armor + Slots.Sum(x => x.Equipment.Info?.Armor ?? 0));
DoCalculations();
}
private void Start()
{
rb = GetComponent <Rigidbody>();
level = new Leveling(1, OnLevelUp);
for (int i = 0; i < attributes.Length; i++)
{
attributes[i].SetParent(this);
}
for (int i = 0; i < equipment.GetSlots.Length; i++)
{
equipment.GetSlots[i].OnBeforeUpdate += OnBeforeSlotUpdate;
equipment.GetSlots[i].OnAfterUpdate += OnAfterSlotUpdate;
}
}
internal static async Task HandleMessages(SocketMessage s)
{
var msg = s as SocketUserMessage;
var context = new SocketCommandContext(_client, msg);
if (msg == null)
{
Console.WriteLine($"{s} not cared for as it's null (for whatever reason)");
return;
}
//Console.WriteLine($"Var msg: {msg}");
//Console.WriteLine($"Var s: {s}");
//Console.WriteLine($"Var context: {context}");
if (context.Guild == null)
{
var user = await context.User.GetOrCreateDMChannelAsync();
await user.SendMessageAsync("Commands are not available in DMs.");
}
var config = GuildConfig.GetGuildConfig(context.Guild.Id) ??
GuildConfig.CreateGuildConfig(context.Guild.Id);
config.GuildOwnerId = context.Guild.Owner.Id;
GuildConfig.SaveGuildConfig();
if (config.Leveling)
{
await Leveling.UserSentMessage((SocketGuildUser)context.User, (SocketTextChannel)context.Channel);
}
if (context.Guild.Id == 385902350432206849)
{
if (msg.Content.Contains("🎷") || msg.Content.Contains("🎺"))
{
if (msg.Author.Id == 360493978371751937)
{
await msg.DeleteAsync();
var msgObj = await context.Channel.SendMessageAsync(context.User.Mention + " no");
Thread.Sleep(5000);
await msgObj.DeleteAsync();
}
}
}
}
private async Task HandleCommandAsync(SocketMessage msg)
{
var argPos = 0;
if (msg.Author.IsBot)
{
return;
}
var userMessage = msg as SocketUserMessage;
if (userMessage == null)
{
return;
}
if (!userMessage.HasStringPrefix("!", ref argPos) || userMessage.HasMentionPrefix(_client.CurrentUser, ref argPos))
{
return;
}
var context = new SocketCommandContext(_client, userMessage);
var result = await _commands.ExecuteAsync(context, argPos, _services);
if (!result.IsSuccess && result.Error != CommandError.UnknownCommand) // If not successful, reply with an error. - Filters out unknown command error as mis-typed commands happen frequently.
{
await context.Channel.SendMessageAsync(result.ErrorReason); // Tell user an error occured
Console.WriteLine($"[{DateTime.UtcNow:t} [Commands] {context.Message.Author.Username}: {context.Message.Content} | Error: {result.ErrorReason}");
await Task.Delay(1500).ConfigureAwait(false);
var application = await context.Client.GetApplicationInfoAsync(); // gets channels from discord client
var ownerDM = await application.Owner.GetOrCreateDMChannelAsync(); // find dm channel to private message me
await ownerDM.SendMessageAsync($"[{DateTime.UtcNow:t} [Commands] {context.Message.Author.Username}: {context.Message.Content} | Error: {result.ErrorReason}"); // private message me with exact error reason
}
// Levelling up related
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Execute the UserSentMessage task within the leveling class - passing in the user who typed the message and the channel they typed it in
await Leveling.UserSentMessage((SocketGuildUser)context.User, (SocketTextChannel)context.Channel); /* CODE PROVIDED BY PETER/SPELOS - https://youtu.be/GpHFj9_aey0 */
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Levelling up end
}
public async Task Xp()
{
var user = (SocketGuildUser)Context.User;
var account = UserAccounts.GetAccount(user);
var embed = new EmbedBuilder();
var p = new PlayerFighter(user);
embed.WithColor(Colors.Get(account.Element.ToString()));
var author = new EmbedAuthorBuilder();
author.WithName(user.DisplayName());
author.WithIconUrl(user.GetAvatarUrl());
embed.WithAuthor(author);
embed.AddField("Level", account.LevelNumber, true);
embed.AddField("XP", account.XP, true);
embed.AddField("XP to level up", Leveling.XPforNextLevel(account.XP), true);
await Context.Channel.SendMessageAsync("", false, embed.Build());
}
//calls this function when the bot recieves a message
private async Task HandleCommandAsync(SocketMessage s)
{
var msg = s as SocketUserMessage;
if (msg == null)
{
return;
}
var context = new SocketCommandContext(_client, msg);
if (context.User.IsBot)
{
return;
}
// mute check
var userAccount = UserAccountList.GetAccount(context.User);
if (userAccount.IsMuted)
{
await context.Message.DeleteAsync();
return;
}
//leveling up logic
Leveling.UserSentMessage((SocketGuildUser)context.User, (SocketTextChannel)context.Channel);
int argPos = 0;
if (msg.HasStringPrefix(Config.bot.cmdPrefix, ref argPos) ||
msg.HasMentionPrefix(_client.CurrentUser, ref argPos))
{
var result = await _service.ExecuteAsync(context, argPos, services);
//if the results is not successful and is not an unknown command, print the reason why we got the error
if (!result.IsSuccess && result.Error != CommandError.UnknownCommand)
{
Console.WriteLine(result.ErrorReason);
}
}
}
public LoggedShip(MasterDataRoot masterData, ShipInBattleEntity e)
{
Info = masterData.ShipInfos[e.Id];
Leveling = new Leveling(e.Level);
Firepower = e.Firepower;
AntiAir = e.AntiAir;
Armor = e.Armor;
Luck = e.Luck;
LineOfSight = e.LineOfSight;
Evasion = e.Evasion;
AntiSubmarine = e.AntiSubmarine;
Fuel = e.Fuel ?? default;
Bullet = e.Bullet ?? default;
Slots = e.Slots?.Select(x => new ImplicitSlot(masterData.EquipmentInfos[x.Id], x.Count, x.ImprovementLevel, x.AirProficiency)).ToBindable();
if (e.ExtraSlot.Id > 0)
{
ExtraSlot = new ImplicitSlot(masterData.EquipmentInfos[e.ExtraSlot.Id], e.ExtraSlot.Count, e.ExtraSlot.ImprovementLevel, e.ExtraSlot.AirProficiency);
}
DoCalculations();
}
private async Task HandleMessageAsync(SocketMessage s)
{
if (!(s is SocketUserMessage msg))
{
return;
}
var context = new SocketCommandContext(client, msg);
if (context.User.IsBot)
{
return;
}
//Check for Profanity here
// Auto Responses
responses.ForEach(async r => await r.Check(msg));
Leveling.UserSentMessage((SocketGuildUser)context.User, (SocketTextChannel)context.Channel);
await Task.CompletedTask;
}
private async Task HandleCommandAsync(SocketMessage s)
{
try
{
var msg = s as SocketUserMessage;
if (msg == null)
{
return;
}
var context = new SocketCommandContext(_client, msg);
UserExpMute author = UsersExpMute.GetExpMute(msg.Author.Id);
if (author.IsMuted)
{
await msg.DeleteAsync();
return;
}
//Leveling up
Leveling.UserSendMessage(context.User);
int argPos = 0;
if (msg.HasStringPrefix(Config.bot.cmdPrefix, ref argPos) ||
msg.HasMentionPrefix(_client.CurrentUser, ref argPos))
{
var result = await _commands.ExecuteAsync(context, argPos, _service);
if (!result.IsSuccess && result.Error != CommandError.UnknownCommand)
{
Console.WriteLine(result.ErrorReason);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
}
private async Task HandleCommandAsync(SocketMessage s)
{
var msg = s as SocketUserMessage;
if (msg == null)
{
return;
}
var context = new SocketCommandContext(_client, msg);
//check for user is muted
var userAccount = UserAccounts.GetAccount(context.User);
if (userAccount.isMuted)
{
await context.Message.DeleteAsync();
return;
}
//Award XP for messages
if (!context.User.IsBot)
{
Leveling.OnUserSentMessage((SocketGuildUser)context.User, (SocketTextChannel)context.Channel);
}
int argPos = 0;
if (msg.HasStringPrefix(Config.bot.cmdPrefix, ref argPos) ||
msg.HasMentionPrefix(_client.CurrentUser, ref argPos))
{
var result = await _service.ExecuteAsync(context, argPos, services : null);
if (!result.IsSuccess && result.Error != CommandError.UnknownCommand)
{
Console.WriteLine(result.ErrorReason);
}
}
}
// Use this for initialization
void Start()
{
Screen.sleepTimeout = SleepTimeout.NeverSleep;
audios = (AudioSource[])GetComponents<AudioSource> ();
//Debug.Log (audios == null);
isDefault = false;
leveling = new Leveling ();
totalMove = 0;
starAchievment = 0;
nextLevel = Application.loadedLevel + 1;
generateMap ();
generateObstacle ();
generateEnemy ();
generatePlayer ();
}
