public sealed class PluginGoodlyEffects : Plugin {

public override string name { get { return "GoodlyEffects"; } }

public override string MCGalaxy_Version { get { return "1.9.2.0"; } }

public override string creator { get { return "Goodly"; } }

const float notAllowedBelowZero = 0;

public class EffectConfig {

//NOT defined in the config file. Filled in at runtime when loaded

public byte ID;

[ConfigByte("pixelU1", "Effect")]

public byte pixelU1 = 1;

[ConfigByte("pixelV1", "Effect")]

public byte pixelV1 = 0;

[ConfigByte("pixelU2", "Effect")]

public byte pixelU2 = 10;

[ConfigByte("pixelV2", "Effect")]

public byte pixelV2 = 10;

[ConfigByte("tintRed", "Effect")]

public byte tintRed = 255;

[ConfigByte("tintGreen", "Effect")]

public byte tintGreen = 255;

[ConfigByte("tintBlue", "Effect")]

public byte tintBlue = 255;

[ConfigByte("frameCount", "Effect")]

public byte frameCount = 1;

[ConfigByte("particleCount", "Effect")]

public byte particleCount = 1;

[ConfigFloat("pixelSize", "Effect", 8, 0, 127.5f)]

public float pixelSize = 8;

[ConfigFloat("sizeVariation", "Effect", 0.0f, notAllowedBelowZero)]

public float sizeVariation;

[ConfigFloat("spread", "Effect", 0.0f, notAllowedBelowZero)]

public float spread;

[ConfigFloat("speed", "Effect", 0.0f)]

public float speed;

[ConfigFloat("gravity", "Effect", 0.0f)]

public float gravity;

[ConfigFloat("baseLifetime", "Effect", 1.0f, notAllowedBelowZero)]

public float baseLifetime = 1.0f;

[ConfigFloat("lifetimeVariation", "Effect", 0.0f, notAllowedBelowZero)]

public float lifetimeVariation;

[ConfigBool("expireUponTouchingGround", "Effect", true)]

public bool expireUponTouchingGround = true;

[ConfigBool("collidesSolid", "Effect", true)]

public bool collidesSolid = true;

[ConfigBool("collidesLiquid", "Effect", true)]

public bool collidesLiquid = true;

[ConfigBool("collidesLeaves", "Effect", true)]

public bool collidesLeaves = true;

[ConfigBool("fullBright", "Effect", true)]

public bool fullBright = true;

//Filled in when loaded. Based on pixelSize

public float offset;

static ConfigElement[] cfg;

public void Load(string effectName) {

if (cfg == null) cfg = ConfigElement.GetAll(typeof(EffectConfig));

ConfigElement.ParseFile(cfg, "effects/"+effectName+".properties", this);

}

public void Save(string effectName) {

if (cfg == null) cfg = ConfigElement.GetAll(typeof(EffectConfig));

ConfigElement.SerialiseSimple(cfg, "effects/"+effectName+".properties", this);

}

}

public const int spawnerLimit = 32;

public static int spawnerAccum;

public static Dictionary<Level, List<EffectSpawner>> spawnersAtLevel = new Dictionary<Level, List<EffectSpawner>>();

public class EffectSpawner {

[ConfigString] public string name;

[ConfigString] public string effectName;

[ConfigString] public string owner;

[ConfigFloat] public float x;

[ConfigFloat] public float y;

[ConfigFloat] public float z;

[ConfigFloat] public float originX;

[ConfigFloat] public float originY;

[ConfigFloat] public float originZ;

//the amount of time (in tenths of seconds) it waits between ticks to attempt to spawn a particle. 0 means it spawns 10 times a second.

[ConfigInt] public int spawnInterval = 0;

//the amount of time (in tenths of seconds) this spawner's interval is offset from default

[ConfigInt] public int spawnTimeOffset = 0;

//the percentage chance it has to actually spawn a particle when it's told to

[ConfigFloat] public float spawnChance = 1;

public static bool CanEditAny(Player p) {

if (LevelInfo.IsRealmOwner(p.name, p.level.name)) { return true; }

ItemPerms perms = CommandExtraPerms.Find("EffectSpawner", 1);

perms = perms == null ? new ItemPerms(LevelPermission.Operator, null, null) : perms;

if (perms.UsableBy(p.Rank)) { return true; }

return false;

}

public bool EditableBy(Player p, string attemptedAction = "modify") {

if (CanEditAny(p)) { return true; }

if (owner == p.name) { return true; }

p.Message("%WYou are not allowed to {0} spawners that you did not create.", attemptedAction);

return false;

}

}

public static void AddSpawner(EffectSpawner spawner, Level lvl, bool save) {

if (!spawnersAtLevel.ContainsKey(lvl)) {

//Logger.Log(LogType.Debug, "We are adding key {0} for the first time.", lvl.MapName);

List<EffectSpawner> spawnerList = new List<EffectSpawner>();

spawnerList.Add(spawner);

spawnersAtLevel.Add(lvl, spawnerList);

} else {

spawnersAtLevel[lvl].Add(spawner);

}

if (save) { SpawnersFile.Save(lvl); }

}

public static void RemoveSpawner(EffectSpawner spawner, Level lvl, bool save) {

if (!spawnersAtLevel.ContainsKey(lvl)) { return; }

spawnersAtLevel[lvl].Remove(spawner);

if (save) { SpawnersFile.Save(lvl); }

}

public static void RemoveAllSpawners(Level lvl, bool save) {

if (!spawnersAtLevel.Remove(lvl)) { return; }

if (save) { SpawnersFile.Save(lvl); }

}

//SHAMEFULLY stolen and edited from BotsFile.cs

public static class SpawnersFile {

public static ThreadSafeCache cache;

public static string spawnerDirectory = "effects/spawners/";

public static string SpawnerPath(string map) { return spawnerDirectory + map + ".json"; }

static ConfigElement[] elems;

public static void Load(Level lvl) {

object locker = cache.GetLocker(lvl.name);

lock (locker) {

LoadCore(lvl);

}

}

static void LoadCore(Level lvl) {

string path = SpawnerPath(lvl.MapName);

if (!File.Exists(path)) return;

string json = File.ReadAllText(path);

List<EffectSpawner> spawners = null;

try {

spawners = ReadAll(json);

} catch (Exception ex) {

Logger.LogError("Reading spawners file", ex); return;

}

foreach (EffectSpawner spawner in spawners) {

AddSpawner(spawner, lvl, false);

}

}

internal static List<EffectSpawner> ReadAll(string json) {

List<EffectSpawner> spawners = new List<EffectSpawner>();

if (elems == null) elems = ConfigElement.GetAll(typeof(EffectSpawner));

JsonContext ctx = new JsonContext(); ctx.Val = json;

JsonArray array = (JsonArray)Json.ParseStream(ctx);

if (array == null) return spawners;

foreach (object raw in array) {

JsonObject obj = (JsonObject)raw;

if (obj == null) continue;

EffectSpawner data = new EffectSpawner();

obj.Deserialise(elems, data);

spawners.Add(data);

}

return spawners;

}

public static void Save(Level lvl) {

object locker = cache.GetLocker(lvl.name);

lock (locker) {

SaveCore(lvl);

}

}

static void SaveCore(Level lvl) {

string path = SpawnerPath(lvl.MapName);

if (!spawnersAtLevel.ContainsKey(lvl)) {

//Logger.Log(LogType.Debug, "There was no key level in spawnersAtLevel");

if (File.Exists(path)) {

File.Delete(path);

//Logger.Log(LogType.Debug, "Deleting file");

}

return;

}

List<EffectSpawner> spawners = spawnersAtLevel[lvl];

if (spawners.Count == 0) {

if (!File.Exists(path)) { return; }

File.Delete(path);

//Logger.Log(LogType.Debug, "There was a key but no spawners. Deleting file");

return;

}

try {

using (StreamWriter w = new StreamWriter(path)) { WriteAll(w, spawners); }

} catch (Exception ex) {

Logger.LogError("Error saving spawners to " + path, ex);

}

}

public static void Delete(string levelName) {

object locker = cache.GetLocker(levelName);

lock (locker) {

DeleteCore(levelName);

}

}

static void DeleteCore(string levelName) {

string path = SpawnerPath(levelName);

if (File.Exists(path)) {

File.Delete(path);

}

}

public static void Copy(string srcMap, string dstMap) {

string srcPath = SpawnerPath(srcMap);

string dstPath = SpawnerPath(dstMap);

File.Copy(srcPath, dstPath);

}

public static void Rename(string srcMap, string dstMap) {

string srcPath = SpawnerPath(srcMap);

string dstPath = SpawnerPath(dstMap);

if (!File.Exists(srcPath)) { return; }

File.Move(srcPath, dstPath);

}

internal static void WriteAll(StreamWriter w, List<EffectSpawner> props) {

w.WriteLine("[");

if (elems == null) elems = ConfigElement.GetAll(typeof(EffectSpawner));

string separator = null;

for (int i = 0; i < props.Count; i++) {

w.Write(separator);

Json.Serialise(w, elems, props[i]);

separator = ",\r\n";

}

w.WriteLine("]");

}

}

public static void DefineEffect(Player p, EffectConfig effect) {

p.Send(Packet.DefineEffect(

effect.ID,

effect.pixelU1,

effect.pixelV1,

effect.pixelU2,

effect.pixelV2,

effect.tintRed,

effect.tintGreen,

effect.tintBlue,

effect.frameCount,

effect.particleCount,

(byte)(effect.pixelSize*2), //convert pixel size to world unit size

effect.sizeVariation,

effect.spread,

effect.speed,

effect.gravity,

effect.baseLifetime,

effect.lifetimeVariation,

effect.expireUponTouchingGround,

effect.collidesSolid,

effect.collidesLiquid,

effect.collidesLeaves,

effect.fullBright ));

}

static Random rnd;

public static Dictionary<string, EffectConfig> effectAtEffectName = new Dictionary<string, EffectConfig>();

public static PlayerExtList playerEffects;

public DateTime startTime = DateTime.UtcNow;

public override void Load(bool startup) {

Command.Register(new CmdReloadEffects());

Command.Register(new CmdEffect());

Command.Register(new CmdSpawner());

rnd = new Random();

LoadEffects();

DefineEffectsAll();

playerEffects = PlayerExtList.Load("extra/playereffects.txt");

OnPlayerMoveEvent.Register(OnPlayerMove, Priority.Low);

OnPlayerFinishConnectingEvent.Register(OnPlayerFinishConnecting, Priority.Low);

OnLevelLoadedEvent.Register(OnLevelLoaded, Priority.Low);

OnLevelUnloadEvent.Register(OnLevelUnload, Priority.Low);

OnLevelDeletedEvent.Register(OnLevelDeleted, Priority.Low);

OnLevelCopiedEvent.Register(OnLevelCopied, Priority.Low);

OnLevelRenamedEvent.Register(OnLevelRenamed, Priority.Low);

SpawnersFile.cache = new ThreadSafeCache();

if (!Directory.Exists(SpawnersFile.spawnerDirectory)) {

Directory.CreateDirectory(SpawnersFile.spawnerDirectory);

}

Level[] levels = LevelInfo.Loaded.Items;

foreach (Level level in levels) {

SpawnersFile.Load(level);

}

spawnerAccum = 0;

ActivateSpawners();

}

public override void Unload(bool shutdown) {

Command.Unregister(Command.Find("ReloadEffects"));

Command.Unregister(Command.Find("Effect"));

Command.Unregister(Command.Find("Spawner"));

OnPlayerMoveEvent.Unregister(OnPlayerMove);

OnPlayerFinishConnectingEvent.Unregister(OnPlayerFinishConnecting);

OnLevelLoadedEvent.Unregister(OnLevelLoaded);

OnLevelUnloadEvent.Unregister(OnLevelUnload);

OnLevelDeletedEvent.Unregister(OnLevelDeleted);

OnLevelCopiedEvent.Unregister(OnLevelCopied);

OnLevelRenamedEvent.Unregister(OnLevelRenamed);

spawnersAtLevel.Clear();

instance.Cancel(tickSpawners);

}

void OnPlayerMove(Player p, Position next, byte yaw, byte pitch) {

string data = playerEffects.FindData(p.name);

if (data == null) return;

if (rnd.NextDouble() > 0.125f && !data.StartsWith("puff")) { return; }

float x = p.Pos.X * 0.03125f;

float y = (p.Pos.Y+ModelInfo.CalcEyeHeight(p) -Entities.CharacterHeight) * 0.03125f;

float z = p.Pos.Z * 0.03125f;

float originX = x;

float originY = y;

float originZ = z;

Player notShownTo = null;

//ugly hack

if (data.StartsWith("leaf")) {

if (rnd.NextDouble() > 0.5f) { return; }

originX+= 32;

originZ+= 8;

} else if (data.StartsWith("puff")) {

Random playerRandom = new Random(p.name.GetHashCode());

const int cycle = 4000;

const int breatheOut = 1000;

int offset = playerRandom.Next(0, cycle+1);

TimeSpan delta = DateTime.UtcNow - (startTime.AddMilliseconds(offset));

int ms = (int)delta.TotalMilliseconds;

bool phase1 = (ms % cycle) < breatheOut;

if (!phase1) { return; }

Vec3F32 dir = DirUtils.GetDirVector(yaw, pitch);

dir.X *= 0.3f;

dir.Y *= 0.3f;

dir.Z *= 0.3f;

originY = y;

x += dir.X;

y += dir.Y;

z += dir.Z;

y -= 0.15f;

originY -= 0.15f;

notShownTo = p;

}

SpawnEffectAt(p.level, data, x, y, z, originX, originY, originZ);

}

static void OnPlayerFinishConnecting(Player p) {

DefineEffectsFor(p);

}

static void OnLevelLoaded(Level lvl) {

SpawnersFile.Load(lvl);

}

static void OnLevelUnload(Level lvl) {

//if the level is forced to stay loaded, don't remove spawners

if (lvl.cancelunload) return;

RemoveAllSpawners(lvl, false);

}

static void OnLevelDeleted(string map) {

SpawnersFile.Delete(map);

}

static void OnLevelCopied(string srcMap, string dstMap) {

SpawnersFile.Copy(srcMap, dstMap);

}

static void OnLevelRenamed(string srcMap, string dstMap) {

SpawnersFile.Rename(srcMap, dstMap);

}

static Scheduler instance;

static SchedulerTask tickSpawners;

public static void ActivateSpawners() {

if (instance == null) instance = new Scheduler("EffectSpawnerScheduler");

tickSpawners = instance.QueueRepeat(SpawnersTick, null, TimeSpan.FromMilliseconds(100));

}

static void SpawnersTick(SchedulerTask task) {

spawnerAccum++;

foreach (Player p in PlayerInfo.Online.Items) {

if (!spawnersAtLevel.ContainsKey(p.level)) { continue; }

List<EffectSpawner> spawners = spawnersAtLevel[p.level];

if (spawners.Count == 0) { continue; }

//We are going to tackle the myth that classicube is minecraft. So, why the "j"? (IDK LOL)

for (int j = 0; j < spawners.Count; j++) {

EffectSpawner spawner = spawners[j];

if (spawner.spawnInterval == 0 || (spawnerAccum+spawner.spawnTimeOffset) % spawner.spawnInterval == 0) {

if (rnd.NextDouble() > spawner.spawnChance) { continue; }

SpawnEffectFor(p, spawner.effectName, spawner.x, spawner.y, spawner.z, spawner.originX, spawner.originY, spawner.originZ);

}

}

}

}

public static void LoadEffects() {

string directory = "effects/";

if (!Directory.Exists(directory)) Directory.CreateDirectory(directory);

DirectoryInfo info = new DirectoryInfo(directory);

FileInfo[] allEffectFiles = info.GetFiles();

for (int i = 0; i < allEffectFiles.Length; i++) {

string realName = Path.GetFileNameWithoutExtension(allEffectFiles[i].Name);

if (i > byte.MaxValue) {

Logger.Log(LogType.Warning, "GoodlyEffects: The maximum of 256 effect files have already been loaded. Effect {0} cannot be loaded!", realName);

continue;

}

EffectConfig effect = new EffectConfig();

effect.Load(realName);

effect.ID = (byte)(i);

effect.offset = effect.pixelSize / 32;

effectAtEffectName[realName] = effect;

Logger.Log(LogType.SystemActivity, "GoodlyEffects: Loaded effect {0} with ID {1}.", realName, i);

}

}

public static void DefineEffectsFor(Player p) {

if (!p.Supports(CpeExt.CustomParticles)) {

p.Message("%WCould not define custom particles because your client is outdated.");

return;

}

p.Socket.LowLatency = true;

foreach(KeyValuePair<string, EffectConfig> entry in effectAtEffectName)

{

DefineEffect(p, entry.Value);

}

}

public static void DefineEffectsAll() {

Player[] players = PlayerInfo.Online.Items;

foreach (Player p in players) {

DefineEffectsFor(p);

}

}

public static void SpawnEffectAt(Level lvl, string effectName, float x, float y, float z, float originX, float originY, float originZ, Player notShownTo = null) {

EffectConfig effect;

if (!effectAtEffectName.TryGetValue(effectName, out effect)) {

Logger.Log(LogType.Warning, "GoodlyEffects: Could not find effect named \"{0}\" !", effectName);

return;

}

Player[] players = PlayerInfo.Online.Items;

foreach (Player p in players) {

if (p.level != lvl || !p.Supports(CpeExt.CustomParticles) || p == notShownTo) { continue; }

p.Send(Packet.SpawnEffect(effect.ID, x, y-effect.offset, z, originX, originY-effect.offset, originZ));

}

}

public static void SpawnEffectFor(Player p, string effectName, float x, float y, float z, float originX, float originY, float originZ) {

EffectConfig effect;

if (!effectAtEffectName.TryGetValue(effectName, out effect)) {

p.Message("%WCould not find effect named \"{0}\" !", effectName);

return;

}

if (!p.Supports(CpeExt.CustomParticles)) { return; }

p.Send(Packet.SpawnEffect(effect.ID, x, y-effect.offset, z, originX, originY-effect.offset, originZ));

}

}

public class CmdReloadEffects : Command2

{

public override string name { get { return "ReloadEffects"; } }

public override string shortcut { get { return ""; } }

public override bool MessageBlockRestricted { get { return true; } }

public override string type { get { return "fun"; } }

public override bool museumUsable { get { return false; } }

public override LevelPermission defaultRank { get { return LevelPermission.Admin; } }

public override void Use(Player p, string message, CommandData data)

{

PluginGoodlyEffects.effectAtEffectName.Clear();

PluginGoodlyEffects.LoadEffects();

PluginGoodlyEffects.DefineEffectsAll();

p.Message("Reloaded effects!");

}

public override void Help(Player p)

{

p.Message("%T/ReloadEffects");

p.Message("%HReloads the effects from the config files.");

}

}

public class CmdEffect : Command2

{

public override string name { get { return "Effect"; } }

public override string shortcut { get { return ""; } }

public override bool MessageBlockRestricted { get { return false; } }

public override string type { get { return "fun"; } }

public override bool museumUsable { get { return false; } }

public override LevelPermission defaultRank { get { return LevelPermission.Admin; } }

public override CommandAlias[] Aliases {

get { return new[] {

new CommandAlias("Effects", "list")

}; }

}

public override void Use(Player p, string message, CommandData data)

{

if (message == "") { Help(p); return; }

if (message.CaselessEq("list")) { ListEffects(p); return; }

string[] words = message.Split(' ');

if (words.Length < 7) {

p.Message("%WYou need to provide effect, x, y, z, originX, originY, and originZ.");

return;

}

string effectName = words[0];

float x = 0, y = 0, z = 0;

float originX = 0, originY = 0, originZ = 0;

bool showToAll = false;

if (!CommandParser.GetReal(p, words[1], "x", ref x)) { return; }

if (!CommandParser.GetReal(p, words[2], "y", ref y)) { return; }

if (!CommandParser.GetReal(p, words[3], "z", ref z)) { return; }

if (!CommandParser.GetReal(p, words[4], "originX", ref originX)) { return; }

if (!CommandParser.GetReal(p, words[5], "originY", ref originY)) { return; }

if (!CommandParser.GetReal(p, words[6], "originZ", ref originZ)) { return; }

if (words.Length >= 8) {

if (!CommandParser.GetBool(p, words[7], ref showToAll)) { return; }

}

PluginGoodlyEffects.EffectConfig effect;

if (!PluginGoodlyEffects.effectAtEffectName.TryGetValue(effectName, out effect)) {

p.Message("%WUnknown effect \"{0}\".", effectName);

return;

}

//default to center of block

x += 0.5f;

y += 0.5f;

z += 0.5f;

originX += x;

originY += y;

originZ += z;

if (showToAll) {

PluginGoodlyEffects.SpawnEffectAt(p.level, effectName, x, y, z, originX, originY, originZ);

} else {

PluginGoodlyEffects.SpawnEffectFor(p, effectName, x, y, z, originX, originY, originZ);

}

}

public void ListEffects(Player p) {

p.Message("Currently available effects:");

foreach(KeyValuePair<string, PluginGoodlyEffects.EffectConfig> entry in PluginGoodlyEffects.effectAtEffectName)

{

p.Message("%H{0}", entry.Key);

}

p.Message("Scroll up to see more effects.");

}

public override void Help(Player p)

{

p.Message("%T/Effect [effect] [x y z] [originX originY originZ] <show to all players>");

p.Message("%HSpawns an effect");

p.Message("%HOrigin is relative and determines the particle's direction.");

p.Message("%HE.G. origin of 0 -1 0 will make the particles move up.");

p.Message("%H[show to all players] is optional true or false.");

p.Message("%T/Effect list %H- Lists currently available effects.");

}

}

public class CmdSpawner : Command2

{

public override string name { get { return "Spawner"; } }

//public override string shortcut { get { return "effectspawner"; } }

public override bool MessageBlockRestricted { get { return true; } }

public override string type { get { return "fun"; } }

public override bool museumUsable { get { return false; } }

public override LevelPermission defaultRank { get { return LevelPermission.Admin; } }

public override bool SuperUseable { get { return false; } }

public override CommandAlias[] Aliases {

get { return new[] {

//new CommandAlias("SpawnerAdd", "add"),

//new CommandAlias("SpawnerRemove", "remove"),

new CommandAlias("Spawners", "list")

}; }

}

public override CommandPerm[] ExtraPerms {

get { return new[] { new CommandPerm(LevelPermission.Operator, "can edit spawners that don't belong to them") }; }

}

public override void Use(Player p, string message, CommandData data)

{

if (message == "") { Help(p); return; }

string[] split = message.SplitSpaces(2);

string func = split[0];

string args = (split.Length < 2) ? "" : split[1];

if (func.CaselessEq("list")) { DoList(p, args); return; }

if (func.CaselessEq("tp")) { DoTP(p, args); return; }

if (!LevelInfo.Check(p, data.Rank, p.level, "modify spawners in this level")) return;

if (func.CaselessEq("add")) { DoAdd(p, args); return; }

if (func.CaselessEq("remove")) { DoRemove(p, args); return; }

if (func.CaselessEq("summon")) { DoSummon(p, args); return; }

p.Message("%W\"{0}\" is not a recognized argument.", func);

p.Message("Please use %T/help spawner%S.");

return;

}

static void DoList(Player p, string message) {

if (message.CaselessEq("all")) {

p.Message("%fADMIN DEBUG LIST");

foreach (KeyValuePair<Level, List<PluginGoodlyEffects.EffectSpawner>> value in PluginGoodlyEffects.spawnersAtLevel) {

p.Message("%fKey is {0}", value.Key.MapName);

foreach (PluginGoodlyEffects.EffectSpawner spawner in value.Value) {

p.Message("%fSpawner is {0}", spawner.name);

}

}

}

if (PluginGoodlyEffects.spawnersAtLevel.ContainsKey(p.level)) {

int count = 0;

p.Message("Spawners in {0}:", p.level.ColoredName);

foreach (PluginGoodlyEffects.EffectSpawner spawner in PluginGoodlyEffects.spawnersAtLevel[p.level]) {

p.Message("{0}, made by {1}", spawner.name, spawner.owner);

count++;

}

p.Message("There are {0} spawners in {1}%S.", count, p.level.ColoredName);

} else {

p.Message("There are no spawners in {0}%S.", p.level.ColoredName);

}

}

static void DoAdd(Player p, string message) {

if (SpawnerCount(p.level) >= PluginGoodlyEffects.spawnerLimit) {

p.Message("%WThe limit of {0} spawners per level has been reached.", PluginGoodlyEffects.spawnerLimit);

p.Message("You may remove spawners with %T/spawner remove%S.");

return;

}

string[] words = message.Split(' ');

if (words.Length < 8) {

p.Message("%WTo add a spawner you need to provide spawner name, effect, x, y, z, originX, originY, and originZ.");

return;

}

string spawnerName = words[0];

if (SpawnerNameExists(p, spawnerName)) { return; }

string effectName = words[1];

PluginGoodlyEffects.EffectConfig effect;

if (!PluginGoodlyEffects.effectAtEffectName.TryGetValue(effectName, out effect)) {

p.Message("%WUnknown effect \"{0}\".", effectName);

return;

}

float x = 0, y = 0, z = 0;

float originX = 0, originY = 0, originZ = 0;

int spawnInterval = 0;

int spawnTimeOffset = 0;

float spawnChance = 1f;

if (!GetCoord(p, words[2], p.Pos.BlockX, "x", out x)) { return; };

if (!GetCoord(p, words[3], p.Pos.FeetBlockCoords.Y, "y", out y)) { return; };

if (!GetCoord(p, words[4], p.Pos.BlockZ, "z", out z)) { return; };

if (!GetCoord(p, words[5], p.Pos.BlockX, "originX", out originX)) { return; };

if (!GetCoord(p, words[6], p.Pos.FeetBlockCoords.Y, "originY", out originY)) { return; };

if (!GetCoord(p, words[7], p.Pos.BlockZ, "originZ", out originZ)) { return; };

if (words.Length > 8) {

if (!CommandParser.GetInt(p, words[8], "spawn interval", ref spawnInterval, 0, 600)) { return; }

}

if (words.Length > 9) {

if (!CommandParser.GetInt(p, words[9], "spawn time offset", ref spawnTimeOffset, 0, 599)) { return; }

}

if (words.Length > 10) {

if (!CommandParser.GetReal(p, words[10], "spawn chance", ref spawnChance, 0.01f, 100)) { return; }

//convert percentage to 0-1

spawnChance /= 100f;

}

//default to center of block

x += 0.5f;

y += 0.5f;

z += 0.5f;

originX += 0.5f;

originY += 0.5f;

originZ += 0.5f;

PluginGoodlyEffects.EffectSpawner spawner = new PluginGoodlyEffects.EffectSpawner();

spawner.name = spawnerName;

spawner.effectName = effectName;

spawner.owner = p.name;

spawner.x = x;

spawner.y = y;

spawner.z = z;

spawner.originX = originX;

spawner.originY = originY;

spawner.originZ = originZ;

spawner.spawnInterval = spawnInterval;

spawner.spawnTimeOffset = spawnTimeOffset;

spawner.spawnChance = spawnChance;

PluginGoodlyEffects.AddSpawner(spawner, p.level, true);

p.Message("Successfully added a spawner named {0}.", spawner.name);

}

static void DoRemove(Player p, string message) {

if (message.CaselessEq("all")) {

if (PluginGoodlyEffects.EffectSpawner.CanEditAny(p)) {

PluginGoodlyEffects.RemoveAllSpawners(p.level, true);

p.Message("Removed all spawners from {0}%S.", p.level.ColoredName);

} else {

p.Message("%WYou cannot remove all spawners unless you are the owner of this map.");

}

return;

}

if (message == "") { p.Message("%WPlease provide the name of a spawner to remove."); return; }

if (!PluginGoodlyEffects.spawnersAtLevel.ContainsKey(p.level)) {

p.Message("There are no spawners in {0}%S.", p.level.ColoredName);

return;

}

int matches;

PluginGoodlyEffects.EffectSpawner spawner = Matcher.Find(p, message, out matches,

PluginGoodlyEffects.spawnersAtLevel[p.level],

x => true,

x => x.name,

"effect spawners");

if (matches > 1 || spawner == null) { return; }

if (spawner.EditableBy(p, "remove")) {

p.Message("Removed spawner {0}.", spawner.name);

PluginGoodlyEffects.RemoveSpawner(spawner, p.level, true);

}

}

static void DoTP(Player p, string message) {

if (!Hacks.CanUseHacks(p)) {

p.Message("%WYou can't teleport to spawners because hacks are disabled in {0}", p.level.ColoredName);

return;

}

if (message == "") { p.Message("%WPlease provide the name of a spawner to teleport to."); return; }

if (!PluginGoodlyEffects.spawnersAtLevel.ContainsKey(p.level)) {

p.Message("There are no spawners in {0}%S to teleport to.", p.level.ColoredName);

return;

}

int matches;

PluginGoodlyEffects.EffectSpawner spawner = Matcher.Find(p, message, out matches,

PluginGoodlyEffects.spawnersAtLevel[p.level],

x => true,

x => x.name,

"effect spawners");

if (matches > 1 || spawner == null) { return; }

Command.Find("tp").Use(p, "-precise "+(int)(spawner.x*32)+" "+(int)(spawner.y*32)+" "+(int)(spawner.z*32));

}

static void DoSummon(Player p, string message) {

if (message == "") { p.Message("%WPlease provide the name of a spawner to summon."); return; }

string[] args = message.SplitSpaces(2);

string spawnerName = args[0];

bool precise = (args.Length > 1) ? args[1].CaselessEq("precise") : false;

p.Message("precise is {0}", precise);

if (!PluginGoodlyEffects.spawnersAtLevel.ContainsKey(p.level)) {

p.Message("There are no spawners in {0}%S.", p.level.ColoredName);

return;

}

int matches;

PluginGoodlyEffects.EffectSpawner spawner = Matcher.Find(p, spawnerName, out matches,

PluginGoodlyEffects.spawnersAtLevel[p.level],

x => true,

x => x.name,

"effect spawners");

if (matches > 1 || spawner == null) { return; }

if (spawner.EditableBy(p, "summon")) {

float diffX = spawner.x - spawner.originX;

float diffY = spawner.y - spawner.originY;

float diffZ = spawner.z - spawner.originZ;

if (precise) {

spawner.x = (float)(p.Pos.X) / 32f;

spawner.y = (float)(p.Pos.Y - Entities.CharacterHeight) / 32f;

spawner.z = (float)(p.Pos.Z) / 32f;

} else {

spawner.x = p.Pos.BlockX;

spawner.y = p.Pos.FeetBlockCoords.Y;

spawner.z = p.Pos.BlockZ;

//center in block

spawner.x += 0.5f;

spawner.y += 0.5f;

spawner.z += 0.5f;

}

spawner.originX = spawner.x - diffX;

spawner.originY = spawner.y - diffY;

spawner.originZ = spawner.z - diffZ;

if (precise) {

p.Message("Summoned spawner {0} to your precise feet position.", spawner.name);

} else {

p.Message("Summoned spawner {0} to your block position.", spawner.name);

}

PluginGoodlyEffects.SpawnersFile.Save(p.level);

}

}

public override void Help(Player p)

{

p.Message("%HSpawner help page 1:");

p.Message("%T/Spawner add");

p.Message("%T[name] [effect] [x y z] [originX originY originZ]");

p.Message("%T<interval> <time offset> <spawn % chance = 100>");

p.Message("%HAdds an effect spawner to the world.");

p.Message("%HPlease use %T/help spawner add %Hfor details on adding.");

p.Message("%HTo read help page 2, type %T/help spawner 2");

}

public override void Help(Player p, string message) {

if (message.CaselessEq("2")) {

p.Message("%HSpawner help page 2:");

p.Message("%T/Spawner remove [name] %H- removes a spawner.");

p.Message("%HIf [name] is \"all\", all spawners are removed.");

p.Message("%T/Spawner tp [name] %H- teleports you to a spawner.");

p.Message("%T/Spawner summon [name] <style> %H- summons a spawner to");

p.Message("%Hyour block position. If <style> is \"precise\",");

p.Message("%Hthe spawner is summoned to your exact feet position.");

p.Message("%T/Spawner list %H- lists spawners in current level.");

return;

}

if (message.CaselessEq("add")) {

p.Message("%fRequired arguments for adding a spawner:");

p.Message("%T[name] %His used to identify the spawner.");

p.Message("%T[effect] %H- the effect this spawner creates.");

p.Message("%HUse %T/effect list %Hto view available effects.");

p.Message("%T[x y z] %H- the coords the effect spawns around.");

p.Message("%T[origin] %H- the coords the effect moves away from.");

p.Message("%HTIP: use ~ for coords relative to you.");

p.Message("%HE.G. %T~ ~0.5 ~");

p.Message("%Hwould make coords at the top of the block you're standing in.");

p.Message("%HUse %T/help spawner options %Hfor optional arguments");

return;

}

if (message.CaselessEq("options")) {

p.Message("%fOptional arguments for adding a spawner:");

p.Message("%T<interval> %H- how long to wait between spawns.");

p.Message("%HAn interval of 10 would spawn once per second.");

p.Message("%T<time offset> %Hoffsets when the effect spawns.");

p.Message("%HAn offset of 5 means half a second.");

p.Message("%T<spawn % chance> %H- chance the effect spawns.");

p.Message("%HThe default is 100, which means it always spawns.");

return;

}

p.Message("There is no help page named \"{0}\".", message);

}

//stolen from CommandParser.cs. Modified to work with float instead of int

static bool GetCoord(Player p, string arg, float cur, string axis, out float value) {

bool relative = arg[0] == '~';

if (relative) arg = arg.Substring(1);

value = 0;

// ~ should work as ~0

if (relative && arg.Length == 0) { value += cur; return true; }

if (!CommandParser.GetReal(p, arg, axis, ref value)) return false;

if (relative) value += cur;

return true;

}

static bool SpawnerNameExists(Player p, string name) {

if (!PluginGoodlyEffects.spawnersAtLevel.ContainsKey(p.level)) { return false; }

foreach (PluginGoodlyEffects.EffectSpawner spawner in PluginGoodlyEffects.spawnersAtLevel[p.level]) {

if (name.CaselessEq(spawner.name)) {

p.Message("A spawner named \"{0}\" already exists.", spawner.name);

return true;

}

}

return false;

}

static int SpawnerCount(Level lvl) {

if (!PluginGoodlyEffects.spawnersAtLevel.ContainsKey(lvl)) { return 0; }

return PluginGoodlyEffects.spawnersAtLevel[lvl].Count;

}

}