API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 6th, 2013
184
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Groovy 16.13 KB | None | 0 0
raw download clone embed print report
  1. package ru.dpohvar.groovy.metaclasses
  2.  
  3. import me.dpohvar.varscript.se.SEProgram;
  4. import me.dpohvar.varscript.se.trigger.SERunnable;
  5. import org.bukkit.inventory.InventoryHolder;
  6. import org.bukkit.inventory.Inventory;
  7. import org.bukkit.inventory.ItemStack;
  8. import org.bukkit.event.Event;
  9. import org.bukkit.event.EventPriority;
  10. import org.bukkit.entity.Player;
  11. import org.bukkit.entity.Entity;
  12. import org.bukkit.entity.HumanEntity;
  13. import org.bukkit.entity.LivingEntity;
  14. import org.bukkit.entity.Item;
  15. import org.bukkit.entity.Player;
  16. import org.bukkit.entity.Damageable;
  17. import org.bukkit.block.Block;
  18. import org.bukkit.util.Vector;
  19. import org.bukkit.Location;
  20. import org.bukkit.World;
  21. import org.bukkit.GameMode;
  22. import org.bukkit.ChatColor;
  23.  
  24. import org.bukkit.Bukkit;
  25.  
  26. /**
  27.  * metaclasses v1.0.0
  28.  * module for VarScript (Bukkit plugin)
  29.  * Author: DPOH-VAR ([email protected])
  30.  * (c) 2013
  31.  */
  32.  
  33. Script.metaClass.vector = { double x,double y,double z ->
  34.     return new Vector(x,y,z)
  35. }
  36. Script.metaClass.up = Script.metaClass.vector ={ double y ->
  37.     new Vector(0,y,0)
  38. }
  39. Script.metaClass.down = { double y ->
  40.     new Vector(0,-y,0)
  41. }
  42. Script.metaClass.player = { String name ->
  43.     Bukkit.getPlayer(name)
  44. }
  45. Script.metaClass.loc = { double x,double y,double z,String world ->
  46.     return new Location(Bukkit.getWorld(world),x,y,z)
  47. }
  48. Script.metaClass.print = { def some ->
  49.     delegate.program.caller.send(some);
  50. }
  51. Script.metaClass.getPlayers = { ->
  52.     return Bukkit.getOnlinePlayers() as List;
  53. }
  54. Script.metaClass.getWorlds = { ->
  55.     return Server.worlds as List
  56. }
  57. Script.metaClass.getEntities = { ->
  58.     List result = new ArrayList()
  59.     for (w in Server.worlds) result += w.entities;
  60.     return result;
  61. }
  62. Script.metaClass.getLiving = { ->
  63.     List result = new ArrayList()
  64.     for (w in Server.worlds)
  65.     for (e in w.entities)
  66.     if (e instanceof LivingEntity)
  67.     result << e
  68.     return result;
  69. }
  70. Script.metaClass.getMobs = { ->
  71.     List result = new ArrayList()
  72.     for (w in Server.worlds)
  73.     for (e in w.entities)
  74.     if (e instanceof LivingEntity)
  75.     if (!(e instanceof Player))
  76.     result << e
  77.     return result;
  78. }
  79.  
  80. Script.metaClass.getItems = { ->
  81.     List result = new ArrayList()
  82.     for (w in Server.worlds)
  83.     for (e in w.entities)
  84.     if (e instanceof Item)
  85.     result << e
  86.     return result;
  87. }
  88. /**
  89.  * Register events easier!
  90. **/
  91. Script.metaClass.onTicks = { long time, Closure closure ->
  92.     return delegate.program.onTicks(closure,time);
  93. }
  94. Script.metaClass.everyTicks = { long time, Closure closure ->
  95.     return delegate.program.everyTicks(closure,time);
  96. }
  97. Script.metaClass.onTimeout = { long time, Closure closure ->
  98.     return delegate.program.onTimeout(closure,time);
  99. }
  100. Script.metaClass.everyTimeout = { long time, Closure closure ->
  101.     return delegate.program.onTimeout(closure,time);
  102. }
  103.  
  104. /**
  105.  * trigger = register { Event event -> ... }
  106.  * trigger = register (priority) { Event event -> ... }
  107.  * trigger = register (String eventType) { ... }
  108.  * trigger = register (String eventType,priority) { ... }
  109.  * trigger = listen { Event event -> ... }
  110.  * trigger = listen (priority) { Event event -> ... }
  111.  * trigger = listen (String eventType) { ... }
  112.  * trigger = listen (String eventType,priority) { ... }
  113.  *
  114. **/
  115. Script.metaClass.register = { final Closure closure ->
  116.     Class[] classes = closure.getParameterTypes();
  117.     assert classes.length == 1
  118.     Class clazz = classes[0]
  119.     assert org.bukkit.event.Event.isAssignableFrom(clazz);
  120.     SERunnable runnable = new SERunnable(){
  121.         public void run(Object event){
  122.             closure(event);
  123.         }
  124.     }
  125.     return delegate.program.onEvent(runnable,clazz,EventPriority.NORMAL,false);
  126. }
  127. Script.metaClass.register = { Object priority, final Closure closure ->
  128.     Class[] classes = closure.getParameterTypes();
  129.     assert classes.length == 1
  130.     Class clazz = classes[0]
  131.     assert org.bukkit.event.Event.isAssignableFrom(clazz);
  132.     SERunnable runnable = new SERunnable(){
  133.         public void run(Object event){
  134.             closure(event);
  135.         }
  136.     }
  137.     return delegate.program.onEvent(runnable,clazz,priority,false);
  138. }
  139. Script.metaClass.listen = { final Closure closure ->
  140.     Class[] classes = closure.getParameterTypes();
  141.     assert classes.length == 1
  142.     Class clazz = classes[0]
  143.     assert org.bukkit.event.Event.isAssignableFrom(clazz);
  144.     SERunnable runnable = new SERunnable(){
  145.         public void run(Object event){
  146.             closure(event);
  147.         }
  148.     }
  149.     return delegate.program.onEvent(runnable,clazz,EventPriority.NORMAL,true);
  150. }
  151. Script.metaClass.listen = { Object priority, final Closure closure ->
  152.     Class[] classes = closure.getParameterTypes();
  153.     assert classes.length == 1
  154.     Class clazz = classes[0]
  155.     assert org.bukkit.event.Event.isAssignableFrom(clazz);
  156.     SERunnable runnable = new SERunnable(){
  157.         public void run(Object event){
  158.             closure(event);
  159.         }
  160.     }
  161.     return delegate.program.onEvent(runnable,clazz,priority,true);
  162. }
  163. Script.metaClass.register = { String type, final Closure closure ->
  164.     SERunnable runnable = new SERunnable(){
  165.         public void run(Object event){
  166.             closure(event);
  167.         }
  168.     }
  169.     return delegate.program.onEvent(runnable,type,EventPriority.NORMAL,false);
  170. }
  171. Script.metaClass.listen = { String type, final Closure closure ->
  172.     SERunnable runnable = new SERunnable(){
  173.         public void run(Object event){
  174.             closure(event);
  175.         }
  176.     }
  177.     return delegate.program.onEvent(runnable,type,EventPriority.NORMAL,true);
  178. }
  179. Script.metaClass.register = { String type, Object priority, final Closure closure ->
  180.     SERunnable runnable = new SERunnable(){
  181.         public void run(Object event){
  182.             closure(event);
  183.         }
  184.     }
  185.     return delegate.program.onEvent(runnable,type,priority,false);
  186. }
  187. Script.metaClass.listen = { String type, Object priority, final Closure closure ->
  188.     SERunnable runnable = new SERunnable(){
  189.         public void run(Object event){
  190.             closure(event);
  191.         }
  192.     }
  193.     return delegate.program.onEvent(runnable,type,priority,true);
  194. }
  195.  
  196.  
  197.  
  198. /**
  199.  * -"playerName"
  200.  * +"formattedString"
  201.  * "world".w
  202.  */
  203. String.metaClass.getP = String.metaClass.negative = { ->
  204.     return Bukkit.getPlayer(delegate);
  205. }
  206. String.metaClass.getW = String.metaClass.bitwiseNegate = { ->
  207.     return Bukkit.getWorld(delegate);
  208. }
  209. String.metaClass.getF = String.metaClass.positive = { ->
  210.     ChatColor.translateAlternateColorCodes('&' as char,delegate)
  211. }
  212. /**
  213.  * vector + vector
  214.  * vector - vector
  215.  * vector / double
  216. **/
  217. Vector.metaClass.plus = { Vector v ->
  218.     return delegate.clone().add(v);
  219. }
  220. Vector.metaClass.minus = { Vector v ->
  221.     return delegate.clone().subtract(v);
  222. }
  223. Vector.metaClass.div = { double d ->
  224.     return delegate.clone().multiply(1/d);
  225. }
  226. java.lang.reflect.Method vectorMulI = Vector.getMethod("multiply",int);
  227. java.lang.reflect.Method vectorMulF = Vector.getMethod("multiply",float);
  228. java.lang.reflect.Method vectorMulD = Vector.getMethod("multiply",double);
  229. Vector.metaClass.multiply = { int d ->
  230.     return vectorMulI.invoke(delegate.clone(),d as int);
  231. }
  232. Vector.metaClass.multiply = { float d ->
  233.     return vectorMulF.invoke(delegate.clone(),d as float);
  234. }
  235. Vector.metaClass.multiply = { double d ->
  236.     return vectorMulD.invoke(delegate.clone(),d as double);
  237. }
  238. Vector.metaClass.negative = { ->
  239.     return delegate.clone().multiply(-1);
  240. }
  241. Vector.metaClass.bitwiseNegate = { ->
  242.     return delegate.clone().normalize();
  243. }
  244. Vector.metaClass.mod = { double d ->
  245.     return delegate.clone().normalize().multiply(d);
  246. }
  247. Vector.metaClass.asType = { Class clazz ->
  248.     if (clazz == byte) return delegate.length();
  249.     if (clazz == short) return delegate.length();
  250.     if (clazz == int) return delegate.length();
  251.     if (clazz == long) return delegate.length();
  252.     if (clazz == float) return delegate.length();
  253.     if (clazz == double) return delegate.length();
  254.     if (Number.isAssignableFrom(clazz)) return delegate.length();
  255. }
  256.  
  257. /**
  258.  * location + vector = location;
  259.  * location - vector = location;
  260.  * location - location = vector;
  261. **/
  262. Location.metaClass.plus = { Vector v ->
  263.     return delegate.clone().add(v);
  264. }
  265. Location.metaClass.minus = { Vector v ->
  266.     return delegate.clone().subtract(v);
  267. }
  268. Location.metaClass.minus = { Location v ->
  269.     if(delegate.world != v.world) return null;
  270.     double x = delegate.x - v.x;
  271.     double y = delegate.y - v.y;
  272.     double z = delegate.z - v.z;
  273.     return new Vector(x,y,z);
  274. }
  275. Location.metaClass.multiply = { int t ->
  276.     assert false, "can't multiply location";
  277. }
  278. Location.metaClass.multiply = { float t ->
  279.     assert false, "can't multiply location";
  280. }
  281. Location.metaClass.multiply = { double t ->
  282.     assert false, "can't multiply location";
  283. }
  284. /**
  285.  * location.thpere(entity)
  286. **/
  287. Location.metaClass.tphere = Location.metaClass.leftShift = { Entity e ->
  288.     e.tp(delegate);
  289.     return delegate;
  290. }
  291. Location.metaClass.getLoc = { ->
  292.     return delegate
  293. }
  294. Location.metaClass.asType = { Class clazz ->
  295.     if (Number.isAssignableFrom(clazz)) return delegate.block.typeId;
  296.     if (Block.isAssignableFrom(clazz)) return delegate.block;
  297.     if (World.isAssignableFrom(clazz)) return delegate.world;
  298. }
  299. /**
  300.  * Location.bolt()
  301.  * create lightning strike at entity
  302. **/
  303. Location.metaClass.bolt = { ->
  304.     World world = delegate.getWorld();
  305.     world.strikeLightning(delegate);
  306.     return delegate;
  307. }
  308. /**
  309.  * Location.bolt(boolean damage)
  310.  * create lightning strike at entity
  311. **/
  312. Location.metaClass.bolt = { boolean damage ->
  313.     World world = delegate.getWorld();
  314.     if(damage) world.strikeLightning(delegate);
  315.     else world.strikeLightningEffect(delegate);
  316.     return delegate;
  317. }
  318.  
  319.  
  320.  
  321. /**
  322.  * block + vector
  323.  * block - vector
  324. **/
  325. Block.metaClass.plus = { Vector v ->
  326.     return delegate.location.add(v).block;
  327. }
  328. Block.metaClass.minus = { Vector v ->
  329.     return delegate.location.subtract(v).block;
  330. }
  331. /**
  332.  * block.thpere(entity)
  333. **/
  334. Block.metaClass.tphere = Block.metaClass.leftShift = { Entity e ->
  335.     e.tp(delegate.location);
  336.     return delegate;
  337. }
  338. Block.metaClass.getLoc = { ->
  339.     return delegate.location
  340. }
  341. Block.metaClass.getBlock = { ->
  342.     return delegate
  343. }
  344. /**
  345.  * Block.bolt()
  346.  * create lightning strike at block
  347. **/
  348. Block.metaClass.bolt = { ->
  349.     World world = delegate.getWorld();
  350.     world.strikeLightning(delegate.getLocation());
  351.     return delegate;
  352. }
  353. /**
  354.  * Block.bolt(boolean damage)
  355.  * create lightning strike at block
  356. **/
  357. Block.metaClass.bolt = { boolean damage ->
  358.     World world = delegate.getWorld();
  359.     if(damage) world.strikeLightning(delegate.getLocation());
  360.     else world.strikeLightningEffect(delegate.getLocation());
  361.     return delegate;
  362. }
  363. Block.metaClass.asType = { Class clazz ->
  364.     if (Number.isAssignableFrom(clazz)) return delegate.typeId;
  365.     if (Location.isAssignableFrom(clazz)) return delegate.location;
  366.     if (World.isAssignableFrom(clazz)) return delegate.world;
  367. }
  368.  
  369.  
  370. /**
  371.  * Entity.throw(double x,double y,double z)
  372.  * add velocity to entity
  373. **/
  374. Entity.metaClass.throw = Entity.metaClass.th = {double x,double y,double z ->
  375.     Vector v = delegate.velocity
  376.     v.x += x
  377.     v.y += y
  378.     v.z += z
  379.     delegate.velocity = v
  380.     return delegate
  381. }
  382. /**
  383.  * Entity.throw(double y)
  384.  * add velocity to entity by Y axis
  385. **/
  386. Entity.metaClass.throw = Entity.metaClass.th =  {double y ->
  387.     Vector v = delegate.velocity
  388.     v.y += y
  389.     delegate.velocity = v
  390.     return delegate
  391. }
  392. /**
  393.  * Entity.throw(Vector v)
  394.  * add velocity to entity
  395. **/
  396. Entity.metaClass.throw = Entity.metaClass.th =  {Vector v ->
  397.     delegate.velocity = delegate.velocity.add(v)
  398.     return delegate
  399. }
  400. /**
  401.  * Entity.bolt()
  402.  * create lightning strike at entity
  403. **/
  404. Entity.metaClass.bolt = { ->
  405.     World world = delegate.getWorld();
  406.     world.strikeLightning(delegate.getLocation());
  407.     return delegate;
  408. }
  409. /**
  410.  * Entity.bolt(boolean damage)
  411.  * create lightning strike at entity
  412. **/
  413. Entity.metaClass.bolt = { boolean damage ->
  414.     World world = delegate.getWorld();
  415.     if(damage) world.strikeLightning(delegate.getLocation());
  416.     else world.strikeLightningEffect(delegate.getLocation());
  417.     return delegate;
  418. }
  419. /**
  420.  * Entity.tp(Location dst)
  421.  * teleport entity to location
  422. **/
  423. Entity.metaClass.tp = Entity.metaClass.rightShift = { Location dst ->
  424.     Location loc = delegate.getLocation();
  425.     loc.x = dst.x
  426.     loc.y = dst.y
  427.     loc.z = dst.z
  428.     loc.world = dst.world
  429.     delegate.teleport(loc)
  430.     return delegate;
  431. }
  432. /**
  433.  * Entity.tp(Entity e)
  434.  * teleport entity to entity
  435. **/
  436. Entity.metaClass.tp = Entity.metaClass.rightShift = { Entity e ->
  437.     Location loc = delegate.getLocation();
  438.     Location dst = e.getLocation();
  439.     loc.x = dst.x
  440.     loc.y = dst.y
  441.     loc.z = dst.z
  442.     loc.world = dst.world
  443.     delegate.teleport(loc)
  444.     return delegate;
  445. }
  446.  
  447. /**
  448.  * Entity.tp(Block e)
  449.  * teleport entity to entity
  450. **/
  451. Entity.metaClass.tp = Entity.metaClass.rightShift = { Block e ->
  452.     Location loc = delegate.getLocation();
  453.     Location dst = e.getLocation();
  454.     loc.x = dst.x
  455.     loc.y = dst.y
  456.     loc.z = dst.z
  457.     loc.world = dst.world
  458.     delegate.teleport(loc)
  459.     return delegate;
  460. }
  461.  
  462. /**
  463.  * Entity.tpto(Location dst)
  464.  * teleport entity to location
  465. **/
  466. Entity.metaClass.tpto = { Location dst ->
  467.     delegate.teleport(dst)
  468.     return delegate;
  469. }
  470.  
  471. /**
  472.  * Entity.tpto(Entity e)
  473.  * teleport entity to entity
  474. **/
  475. Entity.metaClass.tpto = { Entity e ->
  476.     delegate.teleport(e)
  477.     return delegate;
  478. }
  479.  
  480. /**
  481.  * Entity.tpto(Block b)
  482.  * teleport entity to entity
  483. **/
  484. Entity.metaClass.tpto = { Block b ->
  485.     delegate.teleport(b.location)
  486.     return delegate;
  487. }
  488. /**
  489.  * Entity.thpere(entity)
  490. **/
  491. Entity.metaClass.tphere = Entity.metaClass.leftShift = { Entity e ->
  492.     e.tp(delegate.location);
  493.     return delegate;
  494. }
  495. /**
  496.  * Entity.shift(double x,double y,double z)
  497.  * shift entity to x,y,z
  498. **/
  499. Entity.metaClass.shift = { double x,double y,double z ->
  500.     Location l = delegate.getLocation();
  501.     l.x += x;
  502.     l.y += y;
  503.     l.z += z;
  504.     delegate.teleport(l);
  505.     return delegate;
  506. }
  507.  
  508. /**
  509.  * Entity.shift(Vector v)
  510.  * shift entity to vector
  511. **/
  512. Entity.metaClass.shift = { Vector v ->
  513.     delegate.teleport(delegate.location.add(v));
  514.     return delegate;
  515. }
  516. /**
  517.  * Entity.shift(double y)
  518.  * shift entity up
  519. **/
  520. Entity.metaClass.shift = { double y ->
  521.     Location l = delegate.getLocation();
  522.     l.y += y;
  523.     delegate.teleport(l);
  524.     return delegate;
  525. }
  526. Entity.metaClass.getLoc = { ->
  527.     return delegate.location
  528. }
  529. Entity.metaClass.setLoc = { Location l ->
  530.     delegate.teleport(l);
  531.     return delegate;
  532. }
  533. Entity.metaClass.getBlock = { ->
  534.     return delegate.location.block
  535. }
  536.  
  537.  
  538. /**
  539.  * Damageable.kill()
  540. **/
  541. Damageable.metaClass.kill = { ->
  542.     delegate.damage(delegate.getMaxHealth());
  543. }
  544. /**
  545.  * Damageable.dmg(double damage)
  546. **/
  547. Damageable.metaClass.dmg = { double damage ->
  548.     delegate.damage(damage);
  549. }
  550. /**
  551.  * Damageable.hp
  552. **/
  553. Damageable.metaClass.getHp = { ->
  554.     delegate.getHealth();
  555. }
  556. Damageable.metaClass.setHp = { double health ->
  557.     def max = delegate.getMaxHealth();
  558.     if (max < health) health = max;
  559.     delegate.setHealth(health);
  560. }
  561. /**
  562.  * Damageable.maxhp
  563. **/
  564. Damageable.metaClass.getMaxhp = { ->
  565.     delegate.getMaxHealth();
  566. }
  567. Damageable.metaClass.setMaxhp = { double health ->
  568.     delegate.setMaxHealth(health);
  569. }
  570.  
  571.  
  572. /**
  573.  * HumanEntity.gm
  574. **/
  575. HumanEntity.metaClass.getGm = { ->
  576.     delegate.gameMode
  577. }
  578. HumanEntity.metaClass.setGm = { GameMode gm ->
  579.     print("x");
  580.     delegate.gameMode = gm;
  581. }
  582.  
  583.  
  584. /**
  585.  * InventoryHolder.give(int id[, int type[, int amount]])
  586.  * InventoryHolder.give(ItemStack item)
  587.  * give item to holder
  588. **/
  589. InventoryHolder.metaClass.give = { int id ->
  590.     delegate.getInventory().addItem(new ItemStack(id))
  591.     return delegate;
  592. }
  593. InventoryHolder.metaClass.give = { int id,int type ->
  594.     delegate.getInventory().addItem(new ItemStack(id,1,type as byte))
  595.     return delegate;
  596. }
  597. InventoryHolder.metaClass.give = { int id,int type, int amount ->
  598.     delegate.getInventory().addItem(new ItemStack(id,amount,type as byte))
  599.     return delegate;
  600. }
  601. InventoryHolder.metaClass.give = { ItemStack item ->
  602.     delegate.getInventory().addItem(item)
  603.     return delegate;
  604. }
  605.  
  606. /**
  607.  * Inventory.give(int id[, int type[, int amount]])
  608.  * Inventory.give(ItemStack item)
  609.  * give item to holder
  610. **/
  611. Inventory.metaClass.give = { int id ->
  612.     delegate.addItem(new ItemStack(id))
  613.     return delegate;
  614. }
  615. Inventory.metaClass.give = { int id,int type ->
  616.     delegate.addItem(new ItemStack(id,0,type as byte))
  617.     return delegate;
  618. }
  619. Inventory.metaClass.give = { int id,int type, int amount ->
  620.     delegate.addItem(new ItemStack(id,amount,type as byte))
  621.     return delegate;
  622. }
  623. Inventory.metaClass.give = { ItemStack item ->
  624.     delegate.addItem(item)
  625.     return delegate;
  626. }
  627.  
  628.  
  629.  
  630.  
  631.  
  632. Bukkit.broadcastMessage("metaclasses loaded");
  633. return [name:"metaclasses",version:[1,0,0]]
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!