public ErraticStrategy(IAIEntity controlled, int shootCooldown) : base(controlled, shootCooldown)
{
turnCooldown = 5000;
cdHandler = new CooldownHandler(Util.Rand(turnCooldown));
cdHandler.StartCooldown();
}
public Core()
{
Instance = this;
Info = new PluginInfo("BPEssentials", "bpe")
{
Description = "Basic commands for powerful moderation.",
Website = "https://bpessentials.github.io/Docs/"
};
CooldownHandler = new CooldownHandler();
WarpHandler = new WarpHandler();
KitHandler = new KitHandler();
OnReloadRequestAsync();
SetCustomData();
EntityHandler = new EntityHandler();
EntityHandler.LoadEntities();
ModuleHandler = new ModuleHandler();
ModuleHandler.Initialize();
EventsHandler.Add("bpe:reload", new Action(OnReloadRequestAsync));
EventsHandler.Add("bpe:version", new Action <string>(OnVersionRequest));
new Commands.Save().StartSaveTimer();
Logger.LogInfo($"BP Essentials {(IsDevelopmentBuild() ? "[DEVELOPMENT-BUILD] " : "")}v{Version} loaded in successfully!");
}
public Core()
{
Instance = this;
Info = new PluginInfo("BPEssentials", "BPE", new List <PluginAuthor> {
new PluginAuthor("UserR00T"), new PluginAuthor("PLASMA_chicken")
})
{
Description = "Basic commands for powerful moderation.",
Git = "https://github.com/UserR00T/BP-Essentials/",
Website = "https://userr00t.github.io/BP-Essentials/"
};
OnReloadRequestAsync();
SetCutsomData();
CooldownHandler = new CooldownHandler();
WarpHandler = new WarpHandler();
WarpHandler.LoadAll();
KitHandler = new KitHandler();
KitHandler.LoadAll();
EntityHandler = new EntityHandler();
EntityHandler.LoadEntities();
EventsHandler.Add("bpe:reload", new Action(OnReloadRequestAsync));
EventsHandler.Add("bpe:version", new Action <string>(OnVersionRequest));
Logger.LogInfo($"BP Essentials {(IsDevelopmentBuild() ? "[DEVELOPMENT-BUILD] " : "")}v{Version} loaded in successfully!");
}
private void Start()
{
cooldownHandler = CooldownHandler.instance;
image = GetComponent <Image>();
text = GetComponentInChildren <Text>();
cooldown = initialCooldown;
text.text = cooldown.ToString();
}
public NumberPopup(string id, int points, Point2D refPos, List <Color> colors, float vel,
Vector dir, float lifetime, BoundaryStrategy boundaryStrat, Team team, bool optimiseMe
) : base(id, null, refPos, SwinGame.PointAt(0, 0), null, colors, 0, dir.Multiply(vel), dir, boundaryStrat, team, optimiseMe)
{
text = $"+{points}";
cdHandler = new CooldownHandler(lifetime * 1000);
cdHandler.StartCooldown();
}
/// <summary>
/// initialise an ammo object
/// </summary>
/// <param name="pos">spawning position</param>
/// <param name="dir">spawning direction</param>
/// <param name="vel">spawning velocity</param>
public virtual void Init(Point2D pos, Vector dir, Vector vel)
{
//set position and direction of ammo to that of the passed in parent entity
TeleportTo(pos);
theta = Dir.AngleTo(dir) * Math.PI / 180;
MaxVel += vel.Magnitude;
cdHandler = new CooldownHandler(lifetime * 1000);
cdHandler.StartCooldown();
}
public AISpawner(Difficulty diff, Rectangle playArea, ShipFactory shipFactory, IHandlesEntities entHandler)
{
entityHandler = entHandler;
shipFac = shipFactory;
difficulty = diff;
this.playArea = playArea;
cdHandler = new CooldownHandler(diff.SpawnTimer * 1000);
cdHandler.StartCooldown();
}
public Debris(string id, string filePath, Point2D refPos, Point2D offsetPos, Shape shape,
List <Color> colors, BoundaryStrategy boundaryStrat, int health, Vector vel, Vector dir,
float friction, float turnRate, float lifetime, Team team
) : base(id, filePath, refPos, offsetPos, shape, colors, health, vel, dir, boundaryStrat, team)
{
this.friction = friction;
this.turnRate = turnRate;
cdHandler = new CooldownHandler(lifetime * 1000);
cdHandler.StartCooldown();
}
public Emitter(
string id, string filePath, Point2D refPos, Point2D offsetPos,
Vector vel, Vector dir, BoundaryStrategy boundaryStrat, Team team,
float cooldownRate, List <Component> children, IHandlesEntities entHandler
) : base(id, filePath, refPos, offsetPos, null, null, 1, vel, dir, boundaryStrat, team)
{
childComponents = children;
this.cooldownRate = cooldownRate;
cdHandler = new CooldownHandler(1000 / cooldownRate);
this.entHandler = entHandler;
}
public EmittingAmmo(string id, string filePath, Point2D refPos, Point2D offsetPos, Shape shape, List <Color> colors,
int mass, int damage, float lifetime, float vel, float maxVel, float primingDelay, float turnRate,
List <Component> emitters, BoundaryStrategy boundaryStrat, IHandlesEntities entHandler, Team team
) : base(id, filePath, refPos, offsetPos, shape, colors, mass, damage, lifetime, vel, maxVel, turnRate, boundaryStrat, team)
{
primingTimer = new CooldownHandler(primingDelay);
primingTimer.StartCooldown();
this.emitters = emitters;
entityHandler = entHandler;
}
public AIStrategy(IAIEntity controlled, int shootCd = 0)
{
this.controlled = controlled;
targetDir = Util.RandomUnitVector();
commandHistory = new CommandHistory(200);
CreateCommands();
if (shootCd > 0)
{
shootCooldown = new CooldownHandler(shootCd * 1000);
}
}
public Tool(
string id, string filePath, Point2D refPos, Point2D offsetPos, Shape shape,
List <Color> colors, int health, Vector vel, Vector dir, float cooldown, BoundaryStrategy boundaryStrat,
Team team, List <Component> children, int mass, IHandlesEntities entHandler
) : base(id, filePath, refPos, offsetPos, shape, colors, health, vel, dir, boundaryStrat, team)
{
this.cooldown = cooldown;
this.mass = mass <= 0 ? 1 : mass;
childComponents = children;
this.entHandler = entHandler;
cdHandler = new CooldownHandler(cooldown * 1000);
cdHandler.StartCooldown();
}
private void Start()
{
destroyTime = 1.2f;
cooldownW = false;
cooldownQ = false;
cooldownE = false;
cooldownR = false;
cooldownBoom = 3.5f;
barQ = GameObject.Find("BarQ");
cdQ = barQ.GetComponent <CooldownHandler>();
barW = GameObject.Find("BarW");
cdW = barW.GetComponent <CooldownHandler>();
barE = GameObject.Find("BarE");
cdE = barE.GetComponent <CooldownHandler>();
}
public async Task Collect()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
if (account.Inventory.ContainsKey("bitcoin_miner"))
{
var collect = cooldowns.Collect;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(collect, "h", _collectCooldown);
if (isCooledDown)
{
var collected = _collectAmount * account.Inventory["bitcoin_miner"];
account.AddBalance(collected);
cooldowns.Collect = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync($"You've collected {collected} Kredits!");
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, collect.AddHours(_collectCooldown));
await ReplyAsync($"You can only collect once every {_collectCooldown} hours!\n" +
$"You still have to wait for {cooldown}!");
}
}
else
{
await ReplyAsync("You dont generate any passive income yet! Buy a device from the store does!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
/// <summary>
/// Initialise the particle
/// </summary>
/// <param name="pos">spawning position</param>
/// <param name="dir">spawning direction</param>
public void Init(Point2D pos, Vector dir)
{
thrustForce = Util.RandomInRange(velRange);
turnRate = Util.RandomInRange(turnRateRange);
lifetime = Util.RandomInRange(lifetimeRange);
cdHandler = new CooldownHandler(lifetime * 1000);
cdHandler.StartCooldown();
TeleportTo(pos);
double theta = Dir.AngleTo(dir) * Math.PI / 180;
this.theta = theta;
Vector deltaV = dir.Multiply(-thrustForce);
Vel = (Vel.AddVector(deltaV)).LimitToMagnitude(thrustForce);
}
void Start()
{
audioSource = GetComponent <AudioSource>();
cooldowns = new float[3];
player = transform.parent.GetComponent <Player>();
cooldownHandler = player.cooldownHandler;
bulletsTransform = GameObject.Find("bullets").transform;
ball = GameObject.Find("ball");
doesAHumanPlay = player.GetDoesAHumanPlay();
canShootASuperBullet = false;
buttonsValues = player.GetButtonsValues();
if (!doesAHumanPlay)
{
for (int i = 0; i < delays.Length; i++)
{
delays[i] *= 1.2f;
}
}
}
private void Start()
{
_targetList = new List<PlayerObject>();
_gameManager = _gameManagementObject.GetComponent<GameManager>();
_myself =
_currentTarget = _gameManager.GetPlayerObject(_gameManagementObject.GetComponent<LocalPlayer>()._networkPlayer);
_targetRingInstance = Instantiate(_targetRingPrefab) as GameObject;
_cooldownHandle = new CooldownHandler();
}
public async Task Rob(IUser user)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
if (user.Id != Context.Message.Author.Id)
{
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
var targetAccount = db.UserAccounts.AsQueryable().Where(u => u.Id == user.Id).FirstOrDefault();
var targetCooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == user.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
if (account.Inventory.ContainsKey("beat_stick"))
{
if (targetAccount != null && targetCooldowns != null)
{
var rob = cooldowns.Rob;
var robbed = targetCooldowns.Robbed;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(rob, "m", _robCooldown);
var isCooledDownTarget = cooldownHandler.IsCooledDown(robbed, "m", _robCooldown);
if (isCooledDown)
{
if (isCooledDownTarget)
{
var rng = new Random();
var robAmount = rng.Next(_minRob, _maxRob);
if (rng.Next(0, 3) > 0)
{
robAmount = (targetAccount.Balance >= robAmount) ? robAmount : targetAccount.Balance;
account.AddBalance(robAmount);
targetAccount.SubtractBalance(robAmount);
await ReplyAsync($"You stole: {robAmount} Kredits!");
}
else
{
robAmount = (account.Balance >= robAmount) ? robAmount : account.Balance;
account.SubtractBalance(robAmount);
targetAccount.AddBalance(robAmount);
await ReplyAsync($"You were beaten up and lost: {robAmount} Kredits!");
}
cooldowns.Rob = DateTime.Now;
targetCooldowns.Robbed = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
db.Update(targetAccount);
db.Update(targetCooldowns);
await db.SaveChangesAsync();
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, robbed.AddMinutes(_robCooldown));
await ReplyAsync($"Your target can only be robbed once every {_robCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, rob.AddMinutes(_robCooldown));
await ReplyAsync($"You can only rob once every {_robCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("Your target does not have an account yet!");
}
}
else
{
await ReplyAsync("You need a beat stick to rob people with!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
else
{
await ReplyAsync("You can't rob yourself you idiota!");
}
}
public async Task StartTrivia()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
if (!Running)
{
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var lastTrivia = cooldowns.Trivia;
var cooldownHandler = new CooldownHandler();
if (account.Inventory.ContainsKey("trivia_license"))
{
var isCooledDown = cooldownHandler.IsCooledDown(lastTrivia, "m", _triviaCooldown);
if (isCooledDown)
{
Running = true;
cooldowns.Trivia = DateTime.Now;
db.Update(cooldowns);
await db.SaveChangesAsync();
var response = await Client.GetAsync(TriviaUrl);
var responseString = await response.Content.ReadAsStringAsync();
var responseJson = JObject.Parse(responseString);
var score = new Dictionary <ulong, int>();
var stopwatch = new Stopwatch();
await ReplyAsync("A trivia session is starting in 30 seconds...");
await Task.Delay(10000);
await ReplyAsync("A trivia session is starting in 20 seconds...");
await Task.Delay(10000);
await ReplyAsync("A trivia session is starting in 10 seconds...");
await Task.Delay(7000);
await ReplyAsync("A trivia session is starting in 3 seconds...");
await Task.Delay(1000);
await ReplyAsync("A trivia session is starting in 2 seconds...");
await Task.Delay(1000);
await ReplyAsync("A trivia session is starting in 1 seconds...");
await Task.Delay(1000);
await ReplyAsync("Trivia is starting!");
foreach (var result in responseJson["results"])
{
await Task.Delay(2000);
await ReplyAsync(HttpUtility.HtmlDecode(result["question"].ToString()));
this.result = result;
await Task.Delay(2000);
var answers = new List <string>();
answers.Add(result["correct_answer"].ToString());
foreach (var incorrectAnswer in result["incorrect_answers"])
{
answers.Add((string)incorrectAnswer);
}
answers = answers.OrderBy(a => Guid.NewGuid()).ToList();
var answersMessage = string.Join(", ", answers.ToArray());
await ReplyAsync("Answers: " + HttpUtility.HtmlDecode(answersMessage));
Context.Client.MessageReceived += tryAnswer;
stopwatch.Start();
var timeout = false;
while (winnerId == 0)
{
if (stopwatch.ElapsedMilliseconds > 15000)
{
timeout = true;
break;
}
}
stopwatch.Stop();
stopwatch.Reset();
Context.Client.MessageReceived -= tryAnswer;
if (timeout)
{
var correctAnswer = HttpUtility.HtmlDecode((string)result["correct_answer"]);
await ReplyAsync($"The answer was: {correctAnswer}!");
await ReplyAsync("No answer was found, skipping to next question!");
continue;
}
await ReplyAsync($"<@{winnerId}> has found the correct answer!");
if (score.ContainsKey(winnerId))
{
score[winnerId]++;
}
else
{
score.Add(winnerId, 1);
}
winnerId = 0;
if (score.ContainsValue(4) || result == responseJson["results"].Last)
{
break;
}
}
var sortedScores = score.OrderBy(s => s.Value).ToList();
var winners = "";
foreach (var points in sortedScores)
{
winners += $"<@{points.Key}> : {points.Value} points\n";
}
var embed = new EmbedBuilder();
embed.WithColor(new Color(0, 255, 0));
embed.WithTitle("Trivia score");
embed.WithDescription(winners);
await ReplyAsync("", false, embed.Build());
Running = false;
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, lastTrivia.AddMinutes(_triviaCooldown));
await ReplyAsync($"You can only start a trivia session once every {_triviaCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("You can't start a trivia session without a license! Check the $shop.");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
else
{
await ReplyAsync("A trivia session is already running!");
}
}
// Start is called before the first frame update
void Awake()
{
instance = this;
cooldowns = new Dictionary <int, float>();
}
public async Task Work()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var pay = _workAmount;
if (account.Inventory.ContainsKey("working_tools"))
{
pay += (25 * account.Inventory["working_tools"]);
}
if (account.Inventory.ContainsKey("doctors_license"))
{
pay *= (1 + account.Inventory["doctors_license"]);
}
var work = cooldowns.Work;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(work, "m", _workCooldown);
if (isCooledDown)
{
var rng = new Random();
var randNr = rng.Next(0, 3);
if (randNr == 0 && account.Inventory.ContainsKey("vaccine"))
{
randNr = 1;
}
if (randNr > 0)
{
account.AddBalance(pay);
cooldowns.Work = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync($"You've earned {pay} Kredits!");
}
else
{
cooldowns.Work = DateTime.Now;
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync("You got covid and could not show up to work. Unlucky, I guess.");
}
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, work.AddMinutes(_workCooldown));
await ReplyAsync($"You can only work once every {_workCooldown} minutes!\n" +
$"You still have to wait for {cooldown}!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
public async Task SpinRoulette(int bet)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (bet >= _minWager && bet <= _maxWager)
{
if (account != null && cooldowns != null)
{
if (bet <= account.Balance)
{
var lastRoulette = cooldowns.Roulette;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(lastRoulette, "s", _rouletteCooldown);
if (isCooledDown)
{
var rng = new Random();
if (rng.Next(0, 2) > 0)
{
account.AddBalance(bet);
await ReplyAsync($"You won: {bet} Kredits!");
}
else
{
account.SubtractBalance(bet);
await ReplyAsync($"You lost: {bet} Kredits!");
}
cooldowns.Roulette = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, lastRoulette.AddSeconds(_rouletteCooldown));
await ReplyAsync($"You can only roulette once every {_rouletteCooldown} seconds! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("You can't afford that bet!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
else
{
await ReplyAsync($"Wager between {_minWager}-{_maxWager} Kredits!");
}
}
}
