Anvilcraft/ModularPowersuits
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

See extended description

Browse source 
Changed module architecture again
Added rounded corners / borders to gui
Moved all packages into /net/
This commit is contained in:
MachineMuse 2012-12-27 08:49:34 -07:00
parent b9ecec9b43
commit e2904f860e
40 changed files with 0 additions and 6574 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

86
machinemuse/general/geometry/Colour.java
View file

@ -1,86 +0,0 @@
package machinemuse.general.geometry;
import org.lwjgl.opengl.GL11;
/**
* A class representing an RGBA colour and various helper functions. Mainly to
* improve readability elsewhere.
*
* @author MachineMuse
*/
public class Colour {
/**
* The RGBA values are stored as floats from 0.0F (nothing) to 1.0F (full
* saturation/opacity)
*/
public float r, g, b, a;
/**
* Constructor. Just sets the RGBA values to the parameters.
*/
public Colour(float r, float g, float b, float a) {
this.r = r;
this.g = g;
this.b = b;
this.a = a;
}
/**
* Secondary constructor. Sets RGB accordingly and sets alpha to 1.0F (full
* opacity)
*/
public Colour(float r, float g, float b) {
this(r, g, b, 1.0F);
}
/**
* Takes colours in the integer format that Minecraft uses, and converts.
*/
public Colour(int c) {
this.a = (c >> 24 & 255) / 255.0F;
this.r = (c >> 16 & 255) / 255.0F;
this.g = (c >> 8 & 255) / 255.0F;
this.b = (c & 255) / 255.0F;
}
/**
* Returns this colour as an int in Minecraft's format (I think)
*
* @return int value of this colour
*/
public int getInt() {
int val = 0;
val = val | ((int) (a * 255) << 24);
val = val | ((int) (r * 255) << 16);
val = val | ((int) (g * 255) << 8);
val = val | ((int) (b * 255));
return val;
}
/**
* Returns a colour with RGB set to the same value ie. a shade of grey.
*/
public static Colour getGreyscale(float value, float alpha) {
return new Colour(value, value, value, alpha);
}
/**
* Returns a colour at interval interval along a linear gradient from this
* to target
*/
public Colour interpolate(Colour target, float interval) {
float complement = 1 - interval;
return new Colour(
this.r * complement + target.r * interval,
this.g * complement + target.g * interval,
this.b * complement + target.b * interval,
this.a * complement + target.a * interval);
}
public void doGL() {
GL11.glColor4f(r, g, b, a);
}
}

36
machinemuse/general/geometry/FlyFromMiddlePoint2D.java
View file

@ -1,36 +0,0 @@
package machinemuse.general.geometry;
public class FlyFromMiddlePoint2D extends Point2D {
protected long spawnTime;
protected float timeTo;
public FlyFromMiddlePoint2D(float x, float y, float timeTo) {
super(x, y);
spawnTime = System.currentTimeMillis();
this.timeTo = timeTo;
}
public FlyFromMiddlePoint2D(Point2D target, float timeTo) {
this(target.x(), target.y(), timeTo);
}
@Override
public float x() {
return doRatio(x);
}
@Override
public float y() {
return doRatio(y);
}
public float doRatio(float val) {
long elapsed = System.currentTimeMillis() - spawnTime;
float ratio = elapsed / timeTo;
if (ratio > 1.0F) {
return val;
} else {
return val * ratio;
}
}
}

576
machinemuse/general/geometry/MuseRenderer.java
View file

@ -1,576 +0,0 @@
package machinemuse.general.geometry;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import machinemuse.powersuits.gui.MuseGui;
import machinemuse.powersuits.powermodule.PowerModule;
import net.minecraft.client.model.PositionTextureVertex;
import net.minecraft.client.model.TexturedQuad;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.Vec3;
import net.minecraftforge.client.ForgeHooksClient;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
/**
* Contains a bunch of random OpenGL-related functions, accessed statically.
*
* @author MachineMuse
*
*/
public abstract class MuseRenderer {
/**
* Mostly for placeholder graphics, this function draws a 3x3 grid of swirly
* circles over a 16x16 square.
*/
public static void draw3x3placeholder(boolean a, boolean b, boolean c,
boolean d,
boolean e, boolean f, boolean g, boolean h, boolean i) {
if (a)
drawCircleAround(3, 3, 2);
if (b)
drawCircleAround(8, 3, 2);
if (c)
drawCircleAround(13, 3, 2);
if (d)
drawCircleAround(3, 8, 2);
if (e)
drawCircleAround(8, 8, 2);
if (f)
drawCircleAround(13, 8, 2);
if (g)
drawCircleAround(3, 13, 2);
if (h)
drawCircleAround(8, 13, 2);
if (i)
drawCircleAround(13, 13, 2);
}
/**
* Draws a swirly green circle at the specified coordinates in the current
* reference frame.
*
* @param xoffset
* @param yoffset
* @param radius
*/
public static void drawCircleAround(float xoffset, float yoffset,
float radius) {
GL11.glEnable(GL11.GL_DEPTH_TEST);
// GL11.glDepthFunc(GL11.GL_GREATER);
GL11.glDisable(GL11.GL_LIGHTING);
int numSegments = 360;
double theta = (2 * Math.PI) / numSegments;
int start = (int) (System.currentTimeMillis() / 4 % numSegments);
double x = radius * Math.sin(theta * start);
double y = radius * Math.cos(theta * start);
double tf = Math.tan(theta);
double rf = Math.cos(theta);
double tx;
double ty;
Colour c = new Colour(0.0f, 1.0f, 0.0f, 0.0f);
texturelessOn();
smoothingOn();
GL11.glBegin(GL11.GL_LINE_LOOP);
for (int i = 0; i < numSegments; i++) {
GL11.glColor4f(c.r, c.g, c.b, c.a);
GL11.glVertex2d(x + xoffset, y + yoffset);
tx = y;
ty = -x;
x += tx * tf;
y += ty * tf;
x *= rf;
y *= rf;
c.r += theta / 7;
c.b += theta / 7;
c.a += theta / 2;
}
GL11.glEnd();
texturelessOff();
GL11.glDisable(GL11.GL_DEPTH_TEST);
// GL11.glDepthFunc(GL11.GL_LEQUAL);
GL11.glEnable(GL11.GL_LIGHTING);
}
/**
* Draws a swirly green circle at the specified coordinates in the current
* reference frame.
*
* @param xoffset
* @param yoffset
* @param radius
*/
public static void drawTriangles2D(float[] v, float[] c,
int[] i) {
arraysOnC();
texturelessOn();
smoothingOn();
on2D();
// float subdivisions = 5f;
// float radius = 0.5f;
// GL11.glPushMatrix();
// GL11.glTranslatef(-radius, -radius, 0);
// for (int i1 = 0; i1 <= subdivisions * 2; i1++) {
// for (int i2 = 0; i2 <= subdivisions * 2; i2++) {
FloatBuffer vertices = BufferUtils.createFloatBuffer(v.length);
vertices.put(v);
vertices.flip();
FloatBuffer colours = BufferUtils.createFloatBuffer(c.length);
colours.put(c);
colours.flip();
IntBuffer indices = BufferUtils.createIntBuffer(i.length);
indices.put(i);
indices.flip();
// GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
GL11.glVertexPointer(3, 0, vertices);
GL11.glColorPointer(4, 0, colours);
GL11.glDrawElements(GL11.GL_TRIANGLES, indices);
// GL11.glTranslatef(0, radius / subdivisions, 0);
// }
// GL11.glTranslatef(radius / subdivisions, -radius * 2, 0);
// }
// GL11.glPopMatrix();
off2D();
texturelessOff();
arraysOff();
}
/**
* Draws the given vertex arrays (textureless)
*
*/
public static void drawTriangles3DR(float[] v, float[] c,
int[] i) {
arraysOnC();
texturelessOn();
smoothingOn();
// float subdivisions = 5f;
// float radius = 0.5f;
// GL11.glPushMatrix();
// GL11.glTranslatef(-radius, -radius, 0);
// for (int i1 = 0; i1 <= subdivisions * 2; i1++) {
// for (int i2 = 0; i2 <= subdivisions * 2; i2++) {
FloatBuffer vertices = BufferUtils.createFloatBuffer(v.length);
vertices.put(v);
vertices.flip();
FloatBuffer colours = BufferUtils.createFloatBuffer(c.length);
colours.put(c);
colours.flip();
IntBuffer indices = BufferUtils.createIntBuffer(i.length);
indices.put(i);
indices.flip();
// GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
GL11.glVertexPointer(3, 0, vertices);
GL11.glColorPointer(4, 0, colours);
GL11.glDrawElements(GL11.GL_TRIANGLES, indices);
// GL11.glTranslatef(0, radius / subdivisions, 0);
// }
// GL11.glTranslatef(radius / subdivisions, -radius * 2, 0);
// }
// GL11.glPopMatrix();
texturelessOff();
arraysOff();
}
/**
* 2D rendering mode on/off
*/
public static void on2D() {
GL11.glDisable(GL11.GL_DEPTH_TEST);
// GL11.glDisable(GL11.GL_CULL_FACE);
GL11.glDisable(GL11.GL_LIGHTING);
// attempt at fake antialiasing
// GL11.glBlendFunc(GL11.GL_SRC_ALPHA_SATURATE, GL11.GL_ONE);
// GL11.glColorMask(false, false, false, true);
// GL11.glClearColor(0, 0, 0, 0);
// GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
// GL11.glColorMask(true, true, true, true);
// GL11.glHint(GL11.GL_POINT_SMOOTH, GL11.GL_NICEST);
// GL11.glHint(GL11.GL_LINE_SMOOTH, GL11.GL_NICEST);
// GL11.glHint(GL11.GL_POLYGON_SMOOTH, GL11.GL_NICEST);
// GL11.glDepthFunc(GL11.GL_GREATER);
}
public static void off2D() {
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glEnable(GL11.GL_LIGHTING);
}
/**
* Arrays on/off
*/
public static void arraysOnC() {
GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
// GL11.glEnableClientState(GL11.GL_INDEX_ARRAY);
}
public static void arraysOnT() {
GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
GL11.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
// GL11.glEnableClientState(GL11.GL_INDEX_ARRAY);
}
public static void arraysOff() {
GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY);
GL11.glDisableClientState(GL11.GL_COLOR_ARRAY);
GL11.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
// GL11.glDisableClientState(GL11.GL_INDEX_ARRAY);
}
/**
* Call before doing any pure geometry (ie. with colours rather than
* textures).
*/
public static void texturelessOn() {
GL11.glDisable(GL11.GL_TEXTURE_2D);
}
/**
* Call after doing pure geometry (ie. with colours) to go back to the
* texture mode (default).
*/
public static void texturelessOff() {
GL11.glEnable(GL11.GL_TEXTURE_2D);
}
public static void smoothingOn() {
GL11.glShadeModel(GL11.GL_SMOOTH);
GL11.glEnable(GL11.GL_LINE_SMOOTH);
GL11.glEnable(GL11.GL_POLYGON_SMOOTH);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
}
public static void smoothingOff() {
GL11.glShadeModel(GL11.GL_FLAT);
GL11.glDisable(GL11.GL_LINE_SMOOTH);
GL11.glDisable(GL11.GL_POLYGON_SMOOTH);
GL11.glDisable(GL11.GL_BLEND);
// GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
}
/**
* Draws a rectangle with a vertical gradient between the specified colors.
*/
public static void drawGradientRect(float left, float top, float right,
float bottom, Colour c1, Colour c2, double zLevel)
{
texturelessOn();
smoothingOn();
on2D();
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.setColorRGBA_F(c1.r, c1.g, c1.b, c1.a);
tessellator.addVertex(right, top,
zLevel);
tessellator
.addVertex(left, top, zLevel);
tessellator.setColorRGBA_F(c2.r, c2.g, c2.b, c2.a);
tessellator.addVertex(left, bottom,
zLevel);
tessellator.addVertex(right, bottom,
zLevel);
tessellator.draw();
off2D();
texturelessOff();
}
public static void drawGradientRect3D(Vec3 origin, Vec3 size, Colour c1,
Colour c2)
{
Tessellator tessellator = Tessellator.instance;
tessellator.setBrightness(256);
tessellator.startDrawingQuads();
tessellator.setColorRGBA_F(c1.r, c1.g, c1.b, c1.a);
tessellator.addVertex(origin.xCoord, origin.yCoord,
origin.zCoord);
tessellator.addVertex(origin.xCoord + size.xCoord, origin.yCoord,
origin.zCoord);
tessellator.setColorRGBA_F(c2.r, c2.g, c2.b, c2.a);
tessellator.addVertex(origin.xCoord + size.xCoord, origin.yCoord
+ size.yCoord,
origin.zCoord + size.zCoord);
tessellator.addVertex(origin.xCoord, origin.yCoord + size.yCoord,
origin.zCoord + size.zCoord);
tessellator.draw();
}
/**
* Draws a rectangle with the specified texture coords.
*/
public static void drawTexRect(float left, float top, float right,
float bottom, Colour c1, Colour c2, double zLevel)
{
texturelessOff();
smoothingOn();
on2D();
Tessellator tessellator = Tessellator.instance;
tessellator.startDrawingQuads();
tessellator.setColorRGBA_F(c1.r, c1.g, c1.b, c1.a);
tessellator.addVertex(right, top,
zLevel);
tessellator
.addVertex(left, top, zLevel);
tessellator.setColorRGBA_F(c2.r, c2.g, c2.b, c2.a);
tessellator.addVertex(left, bottom,
zLevel);
tessellator.addVertex(right, bottom,
zLevel);
tessellator.draw();
off2D();
texturelessOff();
}
public static void drawItemAt(int x, int y, MuseGui gui, ItemStack item) {
GL11.glEnable(GL11.GL_DEPTH_TEST);
// GL11.glDepthFunc(GL11.GL_GREATER);
GL11.glDisable(GL11.GL_LIGHTING);
gui.getRenderItem().zLevel = 100.0F;
gui.getRenderItem().renderItemAndEffectIntoGUI(
gui.getFontRenderer(), gui.getRenderEngine(), item, x, y);
gui.getRenderItem().renderItemOverlayIntoGUI(gui.getFontRenderer(),
gui.getRenderEngine(), item, x, y);
gui.getRenderItem().zLevel = 0.0F;
GL11.glDisable(GL11.GL_DEPTH_TEST);
// GL11.glDepthFunc(GL11.GL_LEQUAL);
GL11.glEnable(GL11.GL_LIGHTING);
}
public static void drawModuleAt(int x, int y, MuseGui gui,
PowerModule module, NBTTagCompound moduleTag, Colour colour) {
GL11.glPushMatrix();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glEnable(GL11.GL_CULL_FACE);
smoothingOn();
ForgeHooksClient.bindTexture(module.getIconFile(), 0);
if (colour != null)
{
colour.doGL();
}
Tessellator tess = Tessellator.instance;
tess.startDrawingQuads();
float r = 0.0625f;
float u = (module.getIconIndex() % 16) * r;
float v = (module.getIconIndex() / 16) * r;
tess.addVertexWithUV(
x, y, 0,
u, v);
tess.addVertexWithUV(
x, y + 16, 0,
u, v + r);
tess.addVertexWithUV(
x + 16, y + 16, 0,
u + r, v + r);
tess.addVertexWithUV(
x + 16, y, 0,
u + r, v);
tess.draw();
MuseRenderer.smoothingOff();
GL11.glEnable(GL11.GL_CULL_FACE);
// GL11.glDepthFunc(GL11.GL_LEQUAL);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glPopMatrix();
}
/**
*
*/
public static void relativeCoords(MuseGui gui) {
GL11.glPushMatrix();
GL11.glTranslatef(gui.width / 2, gui.height / 2, 0);
GL11.glScalef(gui.getxSize(), gui.getySize(), 0);
}
/**
*
*/
public static void popMatrix() {
GL11.glPopMatrix();
}
/**
* Draws a rectangular prism (cube or otherwise orthogonal)
*/
public static void drawRectPrism(double x, double d, double e,
double f, double z, double g,
float texturex, float texturey,
float texturex2, float texturey2) {
arraysOnT();
texturelessOff();
Vec3[] points = {
Vec3.createVectorHelper(x, e, z),
Vec3.createVectorHelper(d, e, z),
Vec3.createVectorHelper(x, f, z),
Vec3.createVectorHelper(d, f, z),
Vec3.createVectorHelper(x, e, g),
Vec3.createVectorHelper(d, e, g),
Vec3.createVectorHelper(x, f, g),
Vec3.createVectorHelper(d, f, g)
};
PositionTextureVertex[] va1 = {
new PositionTextureVertex(points[0], texturex, texturey2),
new PositionTextureVertex(points[2], texturex2, texturey2),
new PositionTextureVertex(points[3], texturex2, texturey),
new PositionTextureVertex(points[1], texturex, texturey)
};
new TexturedQuad(va1).draw(Tessellator.instance, 1.0F);
PositionTextureVertex[] va2 = {
new PositionTextureVertex(points[2], texturex, texturey2),
new PositionTextureVertex(points[6], texturex2, texturey2),
new PositionTextureVertex(points[7], texturex2, texturey),
new PositionTextureVertex(points[3], texturex, texturey)
};
new TexturedQuad(va2).draw(Tessellator.instance, 1.0F);
PositionTextureVertex[] va3 = {
new PositionTextureVertex(points[6], texturex, texturey2),
new PositionTextureVertex(points[4], texturex2, texturey2),
new PositionTextureVertex(points[5], texturex2, texturey),
new PositionTextureVertex(points[7], texturex, texturey)
};
new TexturedQuad(va3).draw(Tessellator.instance, 1.0F);
PositionTextureVertex[] va4 = {
new PositionTextureVertex(points[4], texturex, texturey2),
new PositionTextureVertex(points[0], texturex2, texturey2),
new PositionTextureVertex(points[1], texturex2, texturey),
new PositionTextureVertex(points[5], texturex, texturey)
};
new TexturedQuad(va4).draw(Tessellator.instance, 1.0F);
PositionTextureVertex[] va5 = {
new PositionTextureVertex(points[1], texturex, texturey2),
new PositionTextureVertex(points[3], texturex2, texturey2),
new PositionTextureVertex(points[7], texturex2, texturey),
new PositionTextureVertex(points[5], texturex, texturey)
};
new TexturedQuad(va5).draw(Tessellator.instance, 1.0F);
PositionTextureVertex[] va6 = {
new PositionTextureVertex(points[0], texturex, texturey2),
new PositionTextureVertex(points[4], texturex2, texturey2),
new PositionTextureVertex(points[6], texturex2, texturey),
new PositionTextureVertex(points[2], texturex, texturey)
};
new TexturedQuad(va6).draw(Tessellator.instance, 1.0F);
// int[] indices = {
// 0, 3, 1,
// 0, 2, 3,
// 2, 6, 7,
// 2, 7, 3,
// 6, 4, 5,
// 6, 5, 7,
// 4, 0, 1,
// 4, 1, 5,
// 1, 3, 7,
// 1, 7, 5,
// 0, 6, 2,
// 0, 4, 6
// };
// drawTriangles3DT(points, textures, indices);
texturelessOff();
arraysOff();
}
private static void drawTriangles3DT(float[] v, float[] textures2,
int[] i) {
arraysOnT();
texturelessOff();
// float subdivisions = 5f;
// float radius = 0.5f;
// GL11.glPushMatrix();
// GL11.glTranslatef(-radius, -radius, 0);
// for (int i1 = 0; i1 <= subdivisions * 2; i1++) {
// for (int i2 = 0; i2 <= subdivisions * 2; i2++) {
FloatBuffer vertices = BufferUtils.createFloatBuffer(v.length);
vertices.put(v);
vertices.flip();
FloatBuffer textures = BufferUtils.createFloatBuffer(textures2.length);
textures.put(textures2);
textures.flip();
IntBuffer indices = BufferUtils.createIntBuffer(i.length);
indices.put(i);
indices.flip();
// GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
GL11.glVertexPointer(3, 0, vertices);
GL11.glTexCoordPointer(2, 0, textures);
GL11.glDrawElements(GL11.GL_TRIANGLES, indices);
// GL11.glTranslatef(0, radius / subdivisions, 0);
// }
// GL11.glTranslatef(radius / subdivisions, -radius * 2, 0);
// }
// GL11.glPopMatrix();
texturelessOff();
arraysOff();
}
}

52
machinemuse/general/geometry/Point2D.java
View file

@ -1,52 +0,0 @@
package machinemuse.general.geometry;
/**
* Base class for Points. The main reason for this is to have a
* pass-by-reference coordinate with getter/setter functions so that points with
* more elaborate behaviour can be implemented - such as for open/close
* animations.
*
* @author MachineMuse
*
*/
public class Point2D {
protected float x;
protected float y;
public Point2D(float x, float y) {
this.x = x;
this.y = y;
}
public Point2D(Point2D p) {
this(p.x, p.y);
}
public float x() {
return x;
}
public float y() {
return y;
}
public void setX(float x) {
this.x = x;
}
public void setY(float y) {
this.y = y;
}
public Point2D plus(Point2D b) {
return new Point2D(x + b.x, y + b.y);
}
public Point2D minus(Point2D b) {
return new Point2D(x - b.x, y - b.y);
}
public Point2D times(float f) {
return new Point2D(x * f, y * f);
}
}

2091
machinemuse/powersuits/block/BlockTinkerTable.java
View file

File diff suppressed because it is too large Load diff

14
machinemuse/powersuits/block/TileEntityTinkerTable.java
View file

@ -1,14 +0,0 @@
/**
*
*/
package machinemuse.powersuits.block;
import net.minecraft.tileentity.TileEntity;
/**
* @author MachineMuse
*
*/
public class TileEntityTinkerTable extends TileEntity {
}

54
machinemuse/powersuits/client/ClientProxy.java
View file

@ -1,54 +0,0 @@
package machinemuse.powersuits.client;
import machinemuse.powersuits.block.TileEntityTinkerTable;
import machinemuse.powersuits.common.CommonProxy;
import machinemuse.powersuits.common.PlayerTickHandler;
import machinemuse.powersuits.common.PowersuitsMod;
import machinemuse.powersuits.network.MusePacketHandler;
import net.minecraft.item.Item;
import net.minecraftforge.client.MinecraftForgeClient;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.common.registry.TickRegistry;
import cpw.mods.fml.relauncher.Side;
/**
* The Client Proxy does all the things that should only be done client-side,
* like registering client-side handlers and renderers.
*
* @author Claire
*
*/
public class ClientProxy extends CommonProxy {
private static EquipmentRenderer eRenderer = new EquipmentRenderer();
/**
* Register all the custom renderers for this mod.
*/
@Override
public void registerRenderers() {
for (Item i : PowersuitsMod.allItems) {
MinecraftForgeClient.registerItemRenderer(
i.shiftedIndex, eRenderer);
}
// for (Item i : PowersuitsMod.allBlocks) {
// MinecraftForgeClient.registerItemRenderer(
// i.shiftedIndex, eRenderer);
// }
ClientRegistry.bindTileEntitySpecialRenderer(
TileEntityTinkerTable.class, new TinkerTableRenderer());
MinecraftForgeClient.preloadTexture("/tinkertable.png");
MinecraftForgeClient.preloadTexture("/moduleicons.png");
}
/**
* Register the tick handler (for on-tick behaviour) and packet handler (for
* network synchronization and permission stuff).
*/
@Override
public void registerHandlers() {
tickHandler = new PlayerTickHandler();
TickRegistry.registerTickHandler(tickHandler, Side.CLIENT);
packetHandler = new MusePacketHandler().register();
}
}

184
machinemuse/powersuits/client/EquipmentRenderer.java
View file

@ -1,184 +0,0 @@
package machinemuse.powersuits.client;
import machinemuse.general.geometry.MuseRenderer;
import machinemuse.powersuits.item.IModularItem;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.RenderEngine;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.world.storage.MapData;
import net.minecraftforge.client.IItemRenderer;
/**
* Custom renderer for the power armor and tools. Note - this only renders the
* item as held in hand, in an inventory slot, or sitting on the ground. To
* render the player's armor is a different interface (not sure yet).
*
* @author MachineMuse
*
*/
public class EquipmentRenderer implements IItemRenderer {
/**
* Forge checks this to see if our custom renderer will handle a certain
* type of rendering.
*
* type can be:
*
* ENTITY - When the item is floating in the world, e.g. after being tossed
* or dropped by a mob.
*
* INVENTORY - Drawing it on an inventory slot.
*
* EQUIPPED - Rendering the item in an entity's hand e.g. endermen.
*
* FIRST_PERSON_MAP - Drawing it in the viewing player's hand
*/
@Override
public boolean handleRenderType(ItemStack item, ItemRenderType type) {
return true;
}
/**
* Called to actually render the item. type is as above, item is the item to
* render, and data is some extra data depending on the type.
*
*/
@Override
public void renderItem(ItemRenderType type, ItemStack itemStack,
Object... data) {
IModularItem item;
if (itemStack.getItem() instanceof IModularItem) {
item = (IModularItem) (itemStack.getItem());
} else {
return;
}
switch (type) {
case ENTITY:
RenderBlocks renderEntity = (RenderBlocks) data[0];
EntityItem entityEntity = (EntityItem) data[1];
break;
case INVENTORY:
RenderBlocks renderInventory = (RenderBlocks) data[0];
break;
case EQUIPPED:
RenderBlocks renderEquipped = (RenderBlocks) data[0];
EntityLiving entityEquipped = (EntityLiving) data[1];
break;
case FIRST_PERSON_MAP:
EntityPlayer playerFirstPerson = (EntityPlayer) data[0];
RenderEngine engineFirstPerson = (RenderEngine) data[1];
MapData mapDataFirstPerson = (MapData) data[2];
break;
default:
}
switch (item.getItemType()) {
case PowerArmorHead:
drawHead(itemStack);
break;
case PowerArmorTorso:
drawTorso(itemStack);
break;
case PowerArmorLegs:
drawLegs(itemStack);
break;
case PowerArmorFeet:
drawFeet(itemStack);
break;
case PowerTool:
drawTool(itemStack);
break;
default:
break;
}
}
public void drawHead(ItemStack itemStack) {
MuseRenderer.draw3x3placeholder(
true, true, true,
true, false, true,
false, false, false);
}
public void drawTorso(ItemStack itemStack) {
MuseRenderer.draw3x3placeholder(
true, false, true,
true, true, true,
true, true, true);
}
public void drawLegs(ItemStack itemStack) {
float z = 1.0F;
float a = 1F;
float[] v = {
2, 1, z,
14, 1, z,
15, 15, z,
9, 15, z,
8, 5, z,
7, 15, z,
1, 15, z
};
float[] c = {
1.0F, 1.0F, 1.0F, a,
0.1F, 0.1F, 0.1F, a,
0.1F, 0.1F, 0.1F, a,
0.7F, 0.7F, 0.7f, a,
0.8F, 0.8F, 0.8F, a,
0.9F, 0.9F, 0.9F, a,
1.0F, 1.0F, 1.0F, a
};
int[] i = {
0, 6, 5,
0, 5, 4,
0, 4, 1,
1, 3, 2,
1, 4, 3
};
MuseRenderer.drawTriangles2D(v, c, i);
}
public void drawFeet(ItemStack itemStack) {
MuseRenderer.draw3x3placeholder(
true, true, true,
false, true, false,
false, true, false);
// MuseRenderer.drawRectPrism(0, 16, 0, 16, 0, 16);
}
public void drawTool(ItemStack itemStack) {
MuseRenderer.draw3x3placeholder(
true, true, true,
false, true, false,
false, true, false);
}
/**
* Whether or not to use the RenderHelper for this item. Helper can be:
*
* ENTITY_ROTATION - Isometric rotation, for block items
*
* ENTITY_BOBBING - Up-and-down bobbing effect for EntityItem
*
* EQUIPPED_BLOCK - Determines if the currently equipped item should be
* rendered as a 3D block or as a 2D texture.
*
* BLOCK_3D - Determines if the item should equate to a block that has
* RenderBlocks.renderItemIn3d return true
*
* INVENTORY_BLOCK - Determines if the item should be rendered in GUI
* inventory slots as a 3D block or as a 2D texture.
*/
@Override
public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item,
ItemRendererHelper helper) {
return false;
}
}

143
machinemuse/powersuits/client/TinkerTableModel.java
View file

@ -1,143 +0,0 @@
package machinemuse.powersuits.client;
import java.util.Random;
import machinemuse.general.geometry.Colour;
import machinemuse.general.geometry.MuseRenderer;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.entity.Entity;
import net.minecraft.util.Vec3;
import org.lwjgl.opengl.GL11;
public class TinkerTableModel extends Render {
// public float onGround;
// public boolean isRiding = false;
protected ModelBase model = new ModelBase() {
};
private static final Random random = new Random();
/**
* This is a list of all the boxes (ModelRenderer.class) in the current
* model.
*/
// public List boxList = new ArrayList();
// public boolean isChild = true;
/** A mapping for all texture offsets */
// private Map modelTextureMap = new HashMap();
// public int textureWidth = 64;
// public int textureHeight = 32;
protected ModelRenderer slab;
protected ModelRenderer legs;
protected ModelRenderer cube;
/**
*
*/
public TinkerTableModel() {
model.textureWidth = 64;
model.textureHeight = 40;
slab = new ModelRenderer(model, 0, 0);
slab.mirror = true;
slab.addBox(
0, 12, 0, // xyz offset of the model
16, 4, 16); // xyz size
// renderer.setRotationPoint(0,0,0);
legs = new ModelRenderer(model, 32, 20);
legs.mirror = true;
legs.addBox(
1, 0, 1,
4, 12, 4);
legs.addBox(
1, 0, 11,
4, 12, 4);
legs.addBox(
11, 0, 1,
4, 12, 4);
legs.addBox(
11, 0, 11,
4, 12, 4);
cube = new ModelRenderer(model, 0, 20);
cube.mirror = true;
cube.addBox(-4, -4, -4, 8, 8, 8);
}
@Override
public void doRender(Entity entity, double x, double y, double z, float f,
float f1) {
int timestep = (int) ((System.currentTimeMillis()) % 10000);
double angle = timestep * Math.PI / 5000.0;
slab.render(0.0625f);
legs.render(0.0625f);
GL11.glPushMatrix();
MuseRenderer.smoothingOn();
OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit,
240.0F, 240.0F);
RenderHelper.disableStandardItemLighting();
GL11.glPushMatrix();
GL11.glTranslated(0.5f, 1.05f, 0.5f);
GL11.glTranslated(0, 0.02f * Math.sin(angle * 3), 0);
// GLRotate uses degrees instead of radians for some reason grr
GL11.glRotatef((float) (angle * 57.2957795131), 0.0f, 1.0f, 0.0f);
GL11.glRotatef(45f, 1.0f, 0.0f, 0.0f);
// arctangent of 0.5.
GL11.glRotatef(35.2643897f, 0, 1, 1);
// cube.render(0.0625f);
cube.render(0.015625f);
// cube.render(0.016000f);
GL11.glPopMatrix();
for (int i = 0; i < 2; i++) {
drawScanLine(angle);
}
GL11.glDisable(GL11.GL_CULL_FACE);
MuseRenderer.drawGradientRect3D(
Vec3.createVectorHelper(0, 1.2, 0),
Vec3.createVectorHelper(1, 0, 1),
new Colour(0.3f, 1.0f, 0.3f, 0.8f),
new Colour(0.3f, 1.0f, 0.3f, 0.8f));
GL11.glEnable(GL11.GL_CULL_FACE);
// MuseRenderer.off2D();
RenderHelper.enableStandardItemLighting();
MuseRenderer.smoothingOff();
GL11.glPopMatrix();
}
private void drawScanLine(double angle) {
float xtarg = random.nextFloat();
float ytarg = random.nextFloat();
GL11.glLineWidth(2);
GL11.glBegin(GL11.GL_LINES);
GL11.glColor4d(0.0, 1.0, 0.2, 1.0);
GL11.glVertex3d(0.5, 1.05 + 0.02f * Math.sin(angle * 3), 0.5);
GL11.glVertex3d(xtarg, 1.2f, ytarg);
GL11.glEnd();
}
/**
* Sets the models various rotation angles then renders the model.
*/
public void render(Entity par1Entity, float par2, float par3, float par4,
float par5, float par6, float par7) {
model.render(par1Entity, par2, par3, par4, par5, par6, par7);
}
// @Override
// protected void setTextureOffset(String par1Str, int par2, int par3)
// {
// this.modelTextureMap.put(par1Str, new TextureOffset(par2, par3));
// }
//
// @Override
// public TextureOffset getTextureOffset(String par1Str)
// {
// return (TextureOffset) this.modelTextureMap.get(par1Str);
// }
}

43
machinemuse/powersuits/client/TinkerTableRenderer.java
View file

@ -1,43 +0,0 @@
/**
*
*/
package machinemuse.powersuits.client;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.client.ForgeHooksClient;
import org.lwjgl.opengl.GL11;
/**
* @author Claire
*
*/
public class TinkerTableRenderer extends TileEntitySpecialRenderer {
protected TinkerTableModel model;
public TinkerTableRenderer() {
model = new TinkerTableModel();
}
@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y,
double z, float partialTickTime) {
ForgeHooksClient.bindTexture("/tinkertable.png", 0);
GL11.glPushMatrix();
GL11.glTranslated(x, y, z);
model.doRender(null, x, y, z, partialTickTime, partialTickTime);
// float texturex = 80 / 256.0f;
// float texturey = 32 / 256.0f;
// float texturex2 = 96 / 256.0f;
// float texturey2 = 48 / 256.0f;
// MuseRenderer.drawRectPrism(
// x, x + 1,
// y + 0.5f, y + 1,
// z, z + 1,
// texturex, texturey, texturex2, texturey2);
GL11.glPopMatrix();
}
}

39
machinemuse/powersuits/common/CommonProxy.java
View file

@ -1,39 +0,0 @@
package machinemuse.powersuits.common;
import machinemuse.powersuits.network.MusePacketHandler;
import cpw.mods.fml.common.ITickHandler;
import cpw.mods.fml.common.registry.TickRegistry;
import cpw.mods.fml.relauncher.Side;
/**
* Server side of the CommonProxy/ClientProxy paradigm. Provides functions which
* the ClientProxy will override if the behaviour is different for client and
* server.
*
* @author MachineMuse
*
*/
public class CommonProxy {
public static String ITEMS_PNG = "/tutorial/generic/items.png";
public static String BLOCK_PNG = "/tutorial/generic/block.png";
public static ITickHandler tickHandler;
public static MusePacketHandler packetHandler;
/**
* Only the client needs to register renderers.
*/
public void registerRenderers() {
}
/**
* Register the server-side tickhandler and packethandler.
*/
public void registerHandlers() {
tickHandler = new PlayerTickHandler();
TickRegistry.registerTickHandler(tickHandler, Side.SERVER);
packetHandler = new MusePacketHandler();
packetHandler.register();
}
}

182
machinemuse/powersuits/common/Config.java
View file

@ -1,182 +0,0 @@
package machinemuse.powersuits.common;
import net.minecraft.block.Block;
import net.minecraft.block.StepSound;
import net.minecraft.block.material.Material;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraftforge.common.Configuration;
/**
* Initial attempt at storing all tweakable/configurable values in one class.
* This got really messy really fast so it's in the process of being reworked.
*
* @author MachineMuse
*
*/
public class Config extends Configuration {
private static final int[] assignedItemIDs = new int[Items.values().length];
private static final int[] assignedBlockIDs = new int[Blocks.values().length];
private static Configuration config;
/**
* Called in the pre-init phase of initialization, informs Forge that we
* want the following blockIDs.
*
* @param config
* The Forge configuration object which will handle such
* requests.
*/
public static void init(Configuration config) {
Config.config = config;
config.load();
// Request block IDs
for (Blocks b : Blocks.values()) {
assignedBlockIDs[b.ordinal()] =
config.getBlock(b.englishName, 1002).getInt();
}
// Request item IDs
for (Items i : Items.values()) {
assignedItemIDs[i.ordinal()] =
config.getItem(i.englishName, 5000).getInt();
}
config.save();
}
/**
* The packet channel for this mod. We will only listen for and send packets
* on this 'channel'. Max of 16 characters.
*
* @return
*/
public static String getNetworkChannelName() {
return "mmmPowerSuits";
}
/**
* The default creative tab to add all these items to. This behaviour may
* change if more items are added, but I doubt it.
*
* @return
*/
public static CreativeTabs getCreativeTab() {
return CreativeTabs.tabMisc;
}
/**
* Once Forge has assigned IDs for all our items, this function will tell us
* what was actually assigned.
*
* @param item
* @return
*/
public static int getAssignedItemID(Items item) {
if (assignedItemIDs[item.ordinal()] == 0) {
assignedItemIDs[item.ordinal()] = config.getItem(item.englishName,
1002).getInt();
}
return assignedItemIDs[item.ordinal()];
}
/**
* Once Forge has assigned IDs for all our blocks, this function will tell
* us what was actually assigned.
*
* @param item
* @return
*/
public static int getAssignedBlockID(Blocks block) {
if (assignedBlockIDs[block.ordinal()] == 0) {
assignedBlockIDs[block.ordinal()] = config.getBlock(
block.englishName, 5000).getInt();
}
return assignedBlockIDs[block.ordinal()];
}
/**
* An enum listing all the blocks that this mod adds. Used for assigning IDs
* and various other things.
*
* @author MachineMuse
*
*/
public static enum Blocks {
TinkerTable(1002, 0, "tinkerTable", "Tinker Table",
80.0F, Material.iron, Block.soundMetalFootstep,
"pickaxe", 1);
public final int defaultBlockId;
public final int textureIndex;
public final String idName;
public final String englishName;
public final float hardness;
public final Material material;
public final StepSound stepSound;
public final String harvestTool;
public final int harvestLevel;
private Blocks(
int defaultBlockId, int textureIndex, String idName,
String englishName,
float hardness, Material material,
StepSound stepSound, String harvestTool, int harvestLevel) {
this.defaultBlockId = defaultBlockId;
this.textureIndex = textureIndex;
this.idName = idName;
this.englishName = englishName;
this.hardness = hardness;
this.material = material;
this.stepSound = stepSound;
this.harvestTool = harvestTool;
this.harvestLevel = harvestLevel;
}
}
/**
* An enum listing all the items that this mod adds. Used for assigning IDs
* and various other things.
*
* @author MachineMuse
*
*/
public static enum Items {
// Icon index, ID name, English name, Armor Type
PowerArmorHead(0, "powerArmorHead", "Power Armor Head"),
PowerArmorTorso(1, "powerArmorTorso", "Power Armor Torso"),
PowerArmorLegs(2, "powerArmorLegs", "Power Armor Legs"),
PowerArmorFeet(3, "powerArmorFeet", "Power Armor Feet"),
PowerTool(4, "powerTool", "Power Tool"),
;
public final int iconIndex;
public final String idName;
public final String englishName;
Items(int iconIndex,
String idName, String englishName) {
this.iconIndex = iconIndex;
this.idName = idName;
this.englishName = englishName;
}
}
/**
* An enum to describe the various GUI windows which can appear. IDs are
* less important here since this data isn't saved or synced.
*
* @author Claire
*
*/
public static enum Guis {
GuiTinkerTable,
GuiSuitManager;
}
public static int getAugMaxID() {
return 256;
}
}

34
machinemuse/powersuits/common/GuiHandler.java
View file

@ -1,34 +0,0 @@
package machinemuse.powersuits.common;
import machinemuse.powersuits.gui.GuiTinkerTable;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.World;
import cpw.mods.fml.common.network.IGuiHandler;
/**
* Gui handler for this mod. Mainly just takes an ID according to what was
* passed to player.OpenGUI, and opens the corresponding GUI.
*
* @author MachineMuse
*
*/
public class GuiHandler implements IGuiHandler {
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world,
int x, int y, int z) {
return null;
}
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world,
int x, int y, int z) {
switch (ID) {
case 0:
return new GuiTinkerTable((EntityClientPlayerMP) player);
default:
return null;
}
}
}

27
machinemuse/powersuits/common/MuseLogger.java
View file

@ -1,27 +0,0 @@
package machinemuse.powersuits.common;
import java.util.logging.Logger;
/**
* Logger access class. May become more fleshed out in the future.
*
* @author MachineMuse
*
*/
public abstract class MuseLogger {
protected final static String DEBUGPREFIX = "MMMPS - DEBUG - ";
protected final static String ERRORPREFIX = "MMMPS - ERROR - ";
public static void logDebug(String string) {
Logger.getLogger("STDOUT").info(DEBUGPREFIX + string);
}
/**
* @param string
*/
public static void logError(String string) {
Logger.getLogger("STDERR").info(ERRORPREFIX + string);
}
}

76
machinemuse/powersuits/common/NBTTagAccessor.java
View file

@ -1,76 +0,0 @@
/**
*
*/
package machinemuse.powersuits.common;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import net.minecraft.nbt.NBTTagCompound;
/**
* Workaround class to access static NBTTagCompound.getTagMap()
*
* @author MachineMuse
*
*/
public class NBTTagAccessor extends NBTTagCompound {
public static Method mTagAccessor;
/**
* Accesses the package-visible
*
* <pre>
* Map NBTTagCompound.getTagMap(NBTTagCompound tag)
* </pre>
*
* Will likely need to be updated every time the obfuscation changes.
*
* @return
*/
public static Method getTagAccessor() {
if (mTagAccessor == null) {
try {
mTagAccessor = NBTTagCompound.class.getDeclaredMethod(
"getTagMap", NBTTagCompound.class);
mTagAccessor.setAccessible(true);
return mTagAccessor;
} catch (NoSuchMethodException e) {
MuseLogger.logError("4");
try {
mTagAccessor = NBTTagCompound.class.getDeclaredMethod(
"a", NBTTagCompound.class);
mTagAccessor.setAccessible(true);
return mTagAccessor;
} catch (NoSuchMethodException e1) {
MuseLogger.logError("1");
e1.printStackTrace();
} catch (SecurityException e1) {
MuseLogger.logError("2");
e1.printStackTrace();
}
} catch (SecurityException e) {
MuseLogger.logError("3");
e.printStackTrace();
}
}
MuseLogger.logError("Error 1: Unable to access nbt tag map!");
return null;
}
public static Map getMap(NBTTagCompound nbt) {
try {
return (Map) getTagAccessor().invoke(null, nbt);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
MuseLogger.logError("Error 2: Unable to access nbt tag map!");
return null;
}
}

89
machinemuse/powersuits/common/PlayerTickHandler.java
View file

@ -1,89 +0,0 @@
/**
*
*/
package machinemuse.powersuits.common;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.List;
import machinemuse.powersuits.item.ItemUtils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import cpw.mods.fml.common.ITickHandler;
import cpw.mods.fml.common.TickType;
/**
* Tick handler for Player ticks. This is where we compute all the updates that
* should go every tick.
*
* @author MachineMuse
*/
public class PlayerTickHandler implements ITickHandler {
@Override
public void tickStart(EnumSet<TickType> type, Object... tickData) {
EntityPlayer player = toPlayer(tickData[0]);
List<NBTTagCompound> playerAugs = ItemUtils
.getPlayerAugs(player);
float totalEnergy = 0;
float totalWeight = 0;
Iterator<NBTTagCompound> iter = playerAugs.iterator();
if (totalWeight > 25) {
player.motionX *= 25 / totalWeight;
player.motionZ *= 25 / totalWeight;
}
}
@Override
public void tickEnd(EnumSet<TickType> type, Object... tickData) {
EntityPlayer player = toPlayer(tickData[0]);
List<ItemStack> stacks = ItemUtils
.getModularItemsInInventory(player.inventory);
}
public static World toWorld(Object data) {
World world = null;
try {
world = (World) data;
} catch (ClassCastException e) {
MuseLogger.logDebug(
"MMMPS: Player tick handler received invalid World object");
e.printStackTrace();
}
return world;
}
public static EntityPlayer toPlayer(Object data) {
EntityPlayer player = null;
try {
player = (EntityPlayer) data;
} catch (ClassCastException e) {
MuseLogger
.logDebug(
"MMMPS: Player tick handler received invalid Player object");
e.printStackTrace();
}
return player;
}
/**
* Type of tick handled by this handler
*/
@Override
public EnumSet<TickType> ticks() {
return EnumSet.of(TickType.PLAYER);
}
/**
* Profiling label for this handler
*/
@Override
public String getLabel() {
return "MMMPS PlayerTickHandler";
}
}

165
machinemuse/powersuits/common/PowersuitsMod.java
View file

@ -1,165 +0,0 @@
package machinemuse.powersuits.common;
import java.util.ArrayList;
import java.util.List;
import machinemuse.powersuits.block.BlockTinkerTable;
import machinemuse.powersuits.item.ItemPowerArmor;
import machinemuse.powersuits.item.ItemPowerArmorFeet;
import machinemuse.powersuits.item.ItemPowerArmorHead;
import machinemuse.powersuits.item.ItemPowerArmorLegs;
import machinemuse.powersuits.item.ItemPowerArmorTorso;
import machinemuse.powersuits.item.ItemPowerTool;
import machinemuse.powersuits.network.MusePacketHandler;
import net.minecraft.block.Block;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.common.Configuration;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.network.NetworkMod;
import cpw.mods.fml.common.network.NetworkMod.SidedPacketHandler;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.registry.GameRegistry;
/**
* Main mod class. This is what Forge loads to get the mod up and running, both
* server- and client-side.
*
* @author MachineMuse
*
*/
// Informs forge that this is a base mod class, and gives it some info for the
// FML mod list. This is also where it looks to see if your client's version
// matches the server's.
@Mod(modid = "mmmPowersuits", name = "MachineMuse Modular Powersuits", version = "0.0.1")
// Informs forge of the requirements:
//
// clientSideRequired means players can't connect without it. True for things
// that add new blocks/items, false for things like bukkit plugins.
//
// serverSideRequired means clients can't connect to servers that don't have it.
// This isn't a strict restriction currently but it can cause problems if the
// mod does anything potentially incompatible in its preInit function. True for
// things that add new blocks/items, false for things like Rei's Minimap or
// Inventory Tweaks.
@NetworkMod(clientSideRequired = true, serverSideRequired = true,
clientPacketHandlerSpec =
@SidedPacketHandler(channels = { "mmPowersuits" }, packetHandler = MusePacketHandler.class),
serverPacketHandlerSpec =
@SidedPacketHandler(channels = { "mmPowersuits" }, packetHandler = MusePacketHandler.class))
public class PowersuitsMod {
/**
* The instance of the mod that Forge will access. Note that it has to be
* set by hand in the preInit step.
*/
@Instance("PowersuitsMod")
public static PowersuitsMod instance;
/**
* Tells Forge what classes to load for the client and server proxies. These
* execute side-specific code like registering renderers (for the client) or
* different tick handlers (for the server).
*/
@SidedProxy(clientSide = "machinemuse.powersuits.client.ClientProxy", serverSide = "machinemuse.powersuits.common.CommonProxy")
public static CommonProxy proxy;
/**
* In the preInit step you only want to load configs, reserve block/item
* IDs, and inform Forge if your mod has to be loaded after any others. No
* heavy loading or registering should occur here, because it happens as
* soon as they start Minecraft and there's no guarantee that your mod will
* be loaded.
*
* @param event
* An event object with useful data
*/
@PreInit
public void preInit(FMLPreInitializationEvent event) {
instance = this;
Config.init(new Configuration(
event.getSuggestedConfigurationFile()));
}
/**
* A static handle for the blocks and items. We only want one instance of
* each of them.
*/
public static List<Block> allBlocks = new ArrayList<Block>();
public static List<Item> allItems = new ArrayList<Item>();
public static GuiHandler guiHandler = new GuiHandler();
/**
* This is where all the heavy loading and registering of handlers goes.
* This occurs when you connect to a server or open a world.
*
* @param event
* An event object with useful data
*/
@Init
public void load(FMLInitializationEvent event) {
loadBlocks();
loadItems();
proxy.registerHandlers();
proxy.registerRenderers();
NetworkRegistry.instance().registerGuiHandler(this, guiHandler);
}
/**
* Custom function to collect all the item-loading in one place.
*/
public static void loadItems() {
ItemPowerArmor item = new ItemPowerArmorHead();
allItems.add(item);
item = new ItemPowerArmorTorso();
allItems.add(item);
item = new ItemPowerArmorLegs();
allItems.add(item);
item = new ItemPowerArmorFeet();
allItems.add(item);
ItemPowerTool tool = new ItemPowerTool();
allItems.add(tool);
}
/**
* Custom function to collect all the block-loading in one place.
*/
public static void loadBlocks() {
Block tinkTable = new BlockTinkerTable();
ItemStack iron = new ItemStack(Item.ingotIron);
ItemStack emerald = new ItemStack(Item.emerald);
ItemStack lapis = new ItemStack(Item.dyePowder, 1);
GameRegistry.addRecipe(new ItemStack(tinkTable),
"ILI",
"LEL",
"ILI",
'I', iron, 'L', lapis, 'E', emerald);
allBlocks.add(tinkTable);
}
/**
* Stuff to do after the player connects. This is for things that need to
* wait until the world is completely loaded before initializing.
*
* @param event
* An event object with useful data
*/
@PostInit
public void postInit(FMLPostInitializationEvent event) {
}
}

105
machinemuse/powersuits/common/WorldTickHandler.java
View file

@ -1,105 +0,0 @@
package machinemuse.powersuits.common;
import java.util.EnumSet;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.World;
import cpw.mods.fml.common.ITickHandler;
import cpw.mods.fml.common.TickType;
/**
* Tick handler for the mod. This is where you put code that should be executed
* once every tick.
*
* @author MachineMuse
*
*/
public class WorldTickHandler implements ITickHandler {
/**
* Called at the "start" phase of a tick
*
* Multiple tick types may fire simultaneously- you will only be called once
* with all the firing ticks
*/
@Override
public void tickStart(EnumSet<TickType> type, Object... tickData) {
World world;
EntityPlayer player;
// if (type.contains(TickType.WORLD)) {
// world = (World) tickData[0];
// }
// TODO: Find a better way to handle this^
}
/**
* Called at the "end" phase of a tick
*
* Multiple ticks may fire simultaneously- you will only be called once with
* all the firing ticks
*/
@Override
public void tickEnd(EnumSet<TickType> type, Object... tickData) {
// TODO Auto-generated method stub
}
/**
* Returns the list of ticks this tick handler is interested in receiving at
* the minute
*/
@Override
public EnumSet<TickType> ticks() {
return EnumSet.of(
TickType.WORLD,
TickType.PLAYER);
// return EnumSet.of(TickType.WORLD);
}
/**
* A profiling label for this tick handler
*/
@Override
public String getLabel() {
return "MachineMuse Powersuits";
}
/**
* Tick types:
*
* WORLD - server and client side - Fired during the world evaluation loop
*
* arg 0 : world object of the world that is ticking
*
*
* RENDER - client side Fired during the render processing phase
*
* arg 0 : float "partial render time"
*
* GUI - client side Fired during the render processing phase if a GUI is
* open
*
* arg 0 : float "partial render time"
*
* arg 1 : the open gui or null if no gui is open
*
*
* CLIENTGUI - client side - Fired during the client evaluation loop arg 0 :
* The open gui or null if no gui is open
*
* WORLDLOAD - server side - Fired once as the world loads from disk
*
* CLIENT - client side - Fired once per client tick loop.
*
* PLAYER - client and server side. - Fired whenever the player's update
* loop runs.
*
* arg 0 : the player
*
* arg 1 : the world the player is in
*
*
* SERVER - server side - This is the server game tick. Fired once per tick
* loop on the server.
*/
}

58
machinemuse/powersuits/energy/EnergyManager.java
View file

@ -1,58 +0,0 @@
/**
*
*/
package machinemuse.powersuits.energy;
import machinemuse.powersuits.powermodule.PowerModule;
import machinemuse.powersuits.powermodule.PowerModuleBattery;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
/**
* Energy Manager will provide a simplified and scalable interface for keeping
* track of all the individual modules in an item which might store, consume, or
* produce power.
*
* @author MachineMuse
*
*/
public class EnergyManager {
public float getStoredEnergy(EntityPlayer player) {
float energy = 0;
for (int i = 0; i < player.inventory.getSizeInventory(); i++) {
ItemStack stack = player.inventory.getStackInSlot(i);
if (stack != null) {
NBTTagCompound tags = PowerModule.getItemModules(stack);
// TODO: Make this scalable
if (tags.hasKey("Electric Battery")) {
NBTTagCompound batteryTag = tags
.getCompoundTag("Electric Battery");
PowerModuleBattery bat = (PowerModuleBattery) PowerModule
.getModuleFromNBT(batteryTag);
energy += bat.getStoredEnergy(player, batteryTag);
}
}
}
return energy;
}
public float getMaxEnergy(EntityPlayer player) {
float energy = 0;
for (int i = 0; i < player.inventory.getSizeInventory(); i++) {
ItemStack stack = player.inventory.getStackInSlot(i);
if (stack != null) {
NBTTagCompound tags = PowerModule.getItemModules(stack);
// TODO: Make this scalable
if (tags.hasKey("Electric Battery")) {
NBTTagCompound batteryTag = tags
.getCompoundTag("Electric Battery");
PowerModuleBattery bat = (PowerModuleBattery) PowerModule
.getModuleFromNBT(batteryTag);
energy += bat.getMaxEnergy(player, batteryTag);
}
}
}
return energy;
}
}

37
machinemuse/powersuits/gui/Clickable.java
View file

@ -1,37 +0,0 @@
package machinemuse.powersuits.gui;
import java.util.List;
import machinemuse.general.geometry.Point2D;
import net.minecraft.client.renderer.RenderEngine;
/**
* Defines a generic clickable item for a MuseGui.
*
* @author MachineMuse
*/
public abstract class Clickable {
protected Point2D position;
public Clickable() {
position = new Point2D(0, 0);
}
public Clickable(Point2D point) {
position = point;
}
public Point2D getPosition() {
return position;
}
public void setPosition(Point2D position) {
this.position = position;
}
public abstract void draw(RenderEngine engine, MuseGui gui);
public abstract boolean hitBox(int x, int y, MuseGui gui);
public abstract List<String> getToolTip();
}

89
machinemuse/powersuits/gui/ClickableButton.java
View file

@ -1,89 +0,0 @@
/**
*
*/
package machinemuse.powersuits.gui;
import java.util.List;
import machinemuse.general.geometry.Colour;
import machinemuse.general.geometry.MuseRenderer;
import machinemuse.general.geometry.Point2D;
import net.minecraft.client.renderer.RenderEngine;
/**
* @author MachineMuse
*
*/
public class ClickableButton extends Clickable {
protected String label;
protected Point2D radius;
protected boolean enabled;
public ClickableButton(String label, Point2D position, Point2D radius,
boolean enabled) {
this.label = label;
this.position = position;
this.radius = radius;
this.enabled = enabled;
}
/*
* (non-Javadoc)
*
* @see
* machinemuse.powersuits.gui.Clickable#draw(net.minecraft.client.renderer
* .RenderEngine, machinemuse.powersuits.gui.MuseGui)
*/
@Override
public void draw(RenderEngine engine, MuseGui gui) {
Colour topcolour;
Colour bottomcolour;
if (enabled) {
topcolour = new Colour(0.5F, 0.6F, 0.8F, 1);
bottomcolour = new Colour(0.3F, 0.3F, 0.3F, 1);
} else {
topcolour = new Colour(0.3F, 0.3F, 0.3F, 1);
bottomcolour = new Colour(0.5F, 0.6F, 0.8F, 1);
}
MuseRenderer.drawGradientRect(
gui.absX(position.x() - radius.x()),
gui.absY(position.y() - radius.y()),
gui.absX(position.x() + radius.x()),
gui.absY(position.y() + radius.y()),
topcolour,
bottomcolour,
0.0F);
gui.drawCenteredString(gui.getFontRenderer(),
this.label,
gui.absX(position.x()),
gui.absY(position.y()) - 4,
Colour.getGreyscale(1.0F, 1.0F).getInt());
}
/*
* (non-Javadoc)
*
* @see machinemuse.powersuits.gui.Clickable#hitBox(int, int,
* machinemuse.powersuits.gui.MuseGui)
*/
@Override
public boolean hitBox(int x, int y, MuseGui gui) {
boolean hitx = Math.abs(x - gui.absX(getPosition().x())) < gui.xSize
* radius.x();
boolean hity = Math.abs(y - gui.absY(getPosition().y())) < gui.ySize
* radius.y();
return hitx && hity;
}
/*
* (non-Javadoc)
*
* @see machinemuse.powersuits.gui.Clickable#getToolTip()
*/
@Override
public List<String> getToolTip() {
// TODO Auto-generated method stub
return null;
}
}

58
machinemuse/powersuits/gui/ClickableItem.java
View file

@ -1,58 +0,0 @@
package machinemuse.powersuits.gui;
import java.util.List;
import machinemuse.general.geometry.MuseRenderer;
import machinemuse.general.geometry.Point2D;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderEngine;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.item.ItemStack;
/**
* Extends the Clickable class to add a clickable ItemStack - note that this
* will be a button that looks like the item, not a container slot.
*
* @author MachineMuse
*/
public class ClickableItem extends Clickable {
public static final int offsetx = 8;
public static final int offsety = 8;
public static RenderItem itemRenderer;
public int inventorySlot;
protected ItemStack item;
public ClickableItem(ItemStack item, Point2D pos, int inventorySlot) {
super(pos);
this.inventorySlot = inventorySlot;
this.item = item;
}
public ItemStack getItem() {
return item;
}
@Override
public boolean hitBox(int x, int y, MuseGui gui) {
boolean hitx = Math.abs(x - gui.absX(getPosition().x())) < offsetx;
boolean hity = Math.abs(y - gui.absY(getPosition().y())) < offsety;
return hitx && hity;
}
@Override
public List<String> getToolTip() {
return item.getTooltip(Minecraft.getMinecraft().thePlayer, false);
}
/**
* Draws the specified itemstack at the *relative* coordinates x,y. Used
* mainly in clickables.
*/
@Override
public void draw(RenderEngine engine, MuseGui gui) {
MuseRenderer.drawItemAt(
gui.absX(getPosition().x()) - offsetx,
gui.absY(getPosition().y()) - offsety,
gui, item);
}
}

65
machinemuse/powersuits/gui/ClickablePowerModule.java
View file

@ -1,65 +0,0 @@
package machinemuse.powersuits.gui;
import java.util.List;
import machinemuse.general.geometry.Colour;
import machinemuse.general.geometry.MuseRenderer;
import machinemuse.general.geometry.Point2D;
import machinemuse.powersuits.powermodule.PowerModule;
import net.minecraft.client.renderer.RenderEngine;
import net.minecraft.nbt.NBTTagCompound;
/**
* Extends the Clickable class to make a clickable Augmentation; note that this
* will not be an actual item.
*
* @author MachineMuse
*/
public class ClickablePowerModule extends Clickable {
protected PowerModule module;
protected NBTTagCompound moduleTag;
/**
* @param vaug
*/
public ClickablePowerModule(PowerModule module, Point2D position) {
super(position);
this.module = module;
this.moduleTag = module.newModuleTag();
}
/**
* @param vaug
*/
public ClickablePowerModule(NBTTagCompound moduleTag, Point2D position) {
super(position);
this.moduleTag = moduleTag;
this.module = PowerModule.getModuleFromNBT(moduleTag);
}
@Override
public List<String> getToolTip() {
return module.getTooltip(
null, null);
}
@Override
public void draw(RenderEngine engine, MuseGui gui) {
int x = gui.absX(getPosition().x());
int y = gui.absY(getPosition().y());
Colour c1 = new Colour(1.0F, 0.2F, 0.6F, 1.0F);
Colour c2 = new Colour(0.6F, 0.2F, 1.0F, 1.0F);
MuseRenderer.drawModuleAt(x - 8, y - 8, gui, module, moduleTag, null);
}
@Override
public boolean hitBox(int x, int y, MuseGui gui) {
boolean hitx = Math.abs(x - gui.absX(getPosition().x())) < 8;
boolean hity = Math.abs(y - gui.absY(getPosition().y())) < 8;
return hitx && hity;
}
}

309
machinemuse/powersuits/gui/GuiTinkerTable.java
View file

@ -1,309 +0,0 @@
package machinemuse.powersuits.gui;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import machinemuse.general.geometry.Colour;
import machinemuse.general.geometry.FlyFromMiddlePoint2D;
import machinemuse.general.geometry.MuseRenderer;
import machinemuse.general.geometry.Point2D;
import machinemuse.powersuits.item.ItemUtils;
import machinemuse.powersuits.network.MusePacketUpgradeRequest;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import cpw.mods.fml.common.network.Player;
/**
* The gui class for the TinkerTable block.
*
* @author MachineMuse
*
*/
public class GuiTinkerTable extends MuseGui {
protected EntityClientPlayerMP player;
protected List<ClickableItem> itemButtons;
protected int selectedItemStack = -1;
protected List<ClickablePowerModule> augButtons;
protected int selectedAugClickable = -1;
protected List<ItemStack> workingUpgradeCost;
protected List<ItemStack> workingDowngradeRefund;
protected ClickableButton upgradeButton;
protected ClickableButton downgradeButton;
/**
* Constructor. Takes a player as an argument.
*
* @param player
*/
public GuiTinkerTable(EntityClientPlayerMP player) {
this.player = player;
this.loadItems();
this.xSize = 256;
this.ySize = 226;
}
/**
* Add the buttons (and other controls) to the screen.
*/
@Override
public void initGui()
{
super.initGui();
}
/**
* Add the clickables for the modular items available
*
*/
public void loadItems() {
itemButtons = new ArrayList<ClickableItem>();
List<Integer> slots = ItemUtils
.getModularItemSlotsInInventory(player.inventory);
List<Point2D> points = this.pointsInLine(slots.size(),
new Point2D(-0.9F, -0.9F),
new Point2D(-0.9F, 0.9F));
Iterator<Integer> slotiterator = slots.iterator();
Iterator<Point2D> pointiterator = points.iterator();
for (int slot : slots) {
ClickableItem clickie = new ClickableItem(
player.inventory.getStackInSlot(slot),
// Fly from middle over 200 ms
new FlyFromMiddlePoint2D(pointiterator.next(), 200), slot);
itemButtons.add(clickie);
}
}
protected void loadAugList(ClickableItem itemClicked) {
augButtons = new ArrayList<ClickablePowerModule>();
List<NBTTagCompound> workingAugs = ItemUtils
.getItemModulesWithPadding(itemClicked
.getItem());
List<Point2D> points = this.pointsInLine(workingAugs.size(),
new Point2D(-0.7F, -0.9F),
new Point2D(-0.7F, 0.9F));
Iterator<Point2D> pointiter = points.iterator();
for (NBTTagCompound aug : workingAugs) {
augButtons.add(new ClickablePowerModule(aug, pointiter.next()));
}
}
// public void drawNthItem(ItemStack stack, int n) {
// // TBI
// // draw item
// // draw a button if it's moddable
// }
//
public void drawSelection() {
if (selectedItemStack != -1) {
MuseRenderer.drawCircleAround(
absX(itemButtons.get(selectedItemStack).getPosition().x()),
absY(itemButtons.get(selectedItemStack).getPosition().y()),
10);
}
if (selectedAugClickable != -1) {
MuseRenderer
.drawCircleAround(
absX(augButtons.get(selectedAugClickable)
.getPosition().x()),
absY(augButtons.get(selectedAugClickable)
.getPosition().y()),
10);
}
}
// public void drawLayout(AugLayout layout) {
//
// }
//
/**
* Draws the background layer for the GUI.
*/
public void drawBackground() {
this.drawDefaultBackground(); // Shading on the world view
this.drawRectangularBackground(); // The window rectangle
}
/**
* Called every frame, draws the screen!
*/
@Override
public void drawScreen(int x, int y, float z) {
super.drawScreen(x, y, z);
drawBackground();
drawClickables(this.itemButtons);
drawSelection();
drawClickables(this.augButtons);
drawUpgradeDowngrade();
drawToolTip();
}
/**
* Draws the upgrade/downgrade cost, buttons, and labels.
*/
public void drawUpgradeDowngrade() {
if (workingUpgradeCost != null && workingUpgradeCost.size() > 0) {
this.drawString(fontRenderer, "Cost:", absX(0.4F),
absY(-0.7F),
new Colour(0.5F, 1.0F, 0.5F, 1.0F).getInt());
List<Point2D> points = this.pointsInLine(workingUpgradeCost.size(),
new Point2D(0.4F, -0.5F),
new Point2D(0.9F, -0.5F));
Iterator<Point2D> pointiter = points.iterator();
for (ItemStack item : workingUpgradeCost) {
Point2D next = pointiter.next();
MuseRenderer.drawItemAt(absX(next.x()), absY(next.y()), this,
item);
}
upgradeButton.draw(this.getRenderEngine(), this);
}
if (workingDowngradeRefund != null && workingDowngradeRefund.size() > 0) {
MuseRenderer.on2D();
this.drawString(fontRenderer, "Refund:", absX(0.4F),
absY(0.3F),
new Colour(1.0F, 0.6F, 0.2F, 1.0F).getInt());
MuseRenderer.off2D();
List<Point2D> points = this.pointsInLine(
workingDowngradeRefund.size(),
new Point2D(0.4F, 0.5F),
new Point2D(0.9F, 0.5F));
Iterator<Point2D> pointiter = points.iterator();
for (ItemStack item : workingDowngradeRefund) {
Point2D next = pointiter.next();
MuseRenderer.drawItemAt(absX(next.x()), absY(next.y()), this,
item);
}
downgradeButton.draw(this.getRenderEngine(), this);
}
}
/**
* Clear all the UI stuff that's there.
*/
protected void clearSelections() {
this.selectedAugClickable = -1;
this.workingUpgradeCost = null;
this.workingDowngradeRefund = null;
this.upgradeButton = null;
this.downgradeButton = null;
}
/**
* Called when the mouse is clicked.
*/
@Override
protected void mouseClicked(int x, int y, int button)
{
if (button == 0) // Left Mouse Button
{
int itemClicked = hitboxClickables(x, y, this.itemButtons);
int augClicked = hitboxClickables(x, y, this.augButtons);
if (itemClicked != -1) {
clearSelections();
this.selectedItemStack = itemClicked;
loadAugList(itemButtons.get(itemClicked));
} else if (augClicked != -1) {
this.selectedAugClickable = augClicked;
refreshUpgrades();
} else if (upgradeButton != null
&& upgradeButton.enabled
&& upgradeButton.hitBox(x, y, this)) {
doUpgrade();
} else if (downgradeButton != null
&& downgradeButton.enabled
&& downgradeButton.hitBox(x, y, this)) {
doDowngrade();
}
}
}
/**
*
*/
private void doDowngrade() {
// TODO Auto-generated method stub
}
/**
* Performs all the functions associated with the upgrade button. This
* requires communicating with the server.
*/
private void doUpgrade() {
if (ItemUtils.hasInInventory(workingUpgradeCost, player.inventory)) {
// ItemUtils.deleteFromInventory(workingUpgradeCost,
// player.inventory);
// workingAugmentation.upgrade();
player.sendQueue
.addToSendQueue(
new MusePacketUpgradeRequest(
(Player) player,
itemButtons.get(selectedItemStack).inventorySlot,
augButtons.get(selectedAugClickable).module
.getName()
).getPacket()
);
// player.sendQueue.sendPacket();
}
}
/**
* Updates the upgrade/downgrade buttons. May someday also include repairs.
*/
private void refreshUpgrades() {
if (selectedAugClickable != -1) {
this.workingUpgradeCost =
augButtons.get(selectedAugClickable).module.getCost(player,
augButtons.get(selectedAugClickable).moduleTag);
if (workingUpgradeCost != null) {
this.upgradeButton = new ClickableButton("Upgrade",
new Point2D(0.6F, -0.2F),
new Point2D(0.25F, 0.05F), true);
if (ItemUtils.hasInInventory(workingUpgradeCost,
player.inventory)) {
upgradeButton.enabled = true;
} else {
upgradeButton.enabled = false;
}
}
}
}
/**
* @return
*/
@Override
protected List<String> getToolTip(int x, int y) {
List<String> hitTip = null;
int itemHover = hitboxClickables(x, y, this.itemButtons);
if (itemHover > -1) {
hitTip = itemButtons.get(itemHover).getToolTip();
}
int augHover = hitboxClickables(x, y, this.augButtons);
if (augHover > -1) {
hitTip = augButtons.get(augHover).getToolTip();
}
return hitTip;
}
@Override
public void refresh() {
loadItems();
if (selectedItemStack != -1 && selectedItemStack < itemButtons.size()) {
loadAugList(itemButtons.get(selectedItemStack));
}
refreshUpgrades();
}
}

292
machinemuse/powersuits/gui/MuseGui.java
View file

@ -1,292 +0,0 @@
package machinemuse.powersuits.gui;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import machinemuse.general.geometry.Colour;
import machinemuse.general.geometry.FlyFromMiddlePoint2D;
import machinemuse.general.geometry.MuseRenderer;
import machinemuse.general.geometry.Point2D;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.RenderEngine;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.RenderItem;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
/**
* I got fed up with Minecraft's gui system so I wrote my own (to some extent.
* Still based on GuiScreen). This class contains a variety of helper functions
* to draw geometry and various other prettifications. Note that MuseGui is
* heavily geometry-based as opposed to texture-based.
*
* @author MachineMuse
*
*/
public class MuseGui extends GuiScreen {
protected static RenderItem renderItem;
protected final boolean usePretty = true;
protected static final Tessellator tesselator = Tessellator.instance;
protected Point2D ul, br;
protected long creationTime;
protected int xSize;
protected int ySize;
public MuseGui() {
super();
}
/**
* Adds the buttons (and other controls) to the screen in question.
*/
@Override
public void initGui() {
super.initGui();
this.controlList.clear();
Keyboard.enableRepeatEvents(true);
creationTime = System.currentTimeMillis();
int xpadding = (width - getxSize()) / 2;
int ypadding = (height - ySize) / 2;
ul = new FlyFromMiddlePoint2D(-1, -1, 150);
br = new FlyFromMiddlePoint2D(1, 1, 150);
}
/**
* Draws the gradient-rectangle background you see in the TinkerTable gui.
*/
public void drawRectangularBackground() {
MuseRenderer.drawGradientRect(
absX(ul.x()), absY(ul.y()),
absX(br.x()), absY(br.y()),
new Colour(0.1F, 0.9F, 0.1F, 0.8F),
new Colour(0.0F, 0.2F, 0.0F, 0.8F),
this.zLevel);
}
/**
* Draws all clickables in a list!
*/
public void drawClickables(List<? extends Clickable> list) {
if (list == null) {
return;
}
Iterator<? extends Clickable> iter = list.iterator();
Clickable clickie;
while (iter.hasNext())
{
clickie = iter.next();
clickie.draw(Minecraft.getMinecraft().renderEngine, this);
}
}
/**
* Returns the first ID in the list that is hit by a click
*
* @return
*/
public int hitboxClickables(int x, int y,
List<? extends Clickable> list) {
if (list == null) {
return -1;
}
Clickable clickie;
for (int i = 0; i < list.size(); i++)
{
clickie = list.get(i);
if (clickie.hitBox(x, y, this)) {
// MuseLogger.logDebug("Hit!");
return i;
}
}
return -1;
}
/**
* Creates a list of points linearly interpolated between points a and b
* noninclusive.
*
* @return A list of num points
*/
public List<Point2D> pointsInLine(int num, Point2D a, Point2D b) {
List<Point2D> points = new ArrayList<Point2D>();
if (num < 1) {
return null;
} else if (num < 2) {
points.add(b.minus(a).times(0.5F).plus(a));
} else {
Point2D step = b.minus(a).times(1.0F / (num + 1));
for (int i = 1; i < num + 2; i++) {
points.add(a.plus(step.times(i)));
}
}
return points;
}
/**
* Whether or not this gui pauses the game in single player.
*/
@Override
public boolean doesGuiPauseGame()
{
return false;
}
/**
* Singleton pattern for the RenderItem
*
* @return the static renderItem instance
*/
public static RenderItem getRenderItem() {
if (renderItem == null) {
renderItem = new RenderItem();
}
return renderItem;
}
/**
* Singleton pattern for FontRenderer
*/
public static FontRenderer getFontRenderer() {
return Minecraft.getMinecraft().fontRenderer;
}
/**
* Singleton pattern for RenderEngine
*/
public static RenderEngine getRenderEngine() {
return Minecraft.getMinecraft().renderEngine;
}
/**
* Returns absolute screen coordinates (int 0 to width) from a relative
* coordinate (float -1.0F to +1.0F)
*
* @param relx
* Relative X coordinate
* @return Absolute X coordinate
*/
public int absX(float relx) {
int absx = (int) ((relx + 1) * getxSize() / 2);
int xpadding = (width - getxSize()) / 2;
return absx + xpadding;
}
/**
* Returns relative coordinate (float -1.0F to +1.0F) from absolute
* coordinates (int 0 to width)
*
*/
public int relX(float absx) {
int padding = (width - getxSize()) / 2;
int relx = (int) ((absx - padding) * 2 / getxSize() - 1);
return relx;
}
/**
* Returns absolute screen coordinates (int 0 to width) from a relative
* coordinate (float -1.0F to +1.0F)
*
* @param relx
* Relative Y coordinate
* @return Absolute Y coordinate
*/
public int absY(float rely) {
int absy = (int) ((rely + 1) * ySize / 2);
int ypadding = (height - ySize) / 2;
return absy + ypadding;
}
/**
* Returns relative coordinate (float -1.0F to +1.0F) from absolute
* coordinates (int 0 to width)
*
*/
public int relY(float absy) {
int padding = (height - ySize) / 2;
int rely = (int) ((absy - padding) * 2 / ySize - 1);
return rely;
}
/**
* @return the xSize
*/
public int getxSize() {
return xSize;
}
/**
* @param xSize
* the xSize to set
*/
public void setxSize(int xSize) {
this.xSize = xSize;
}
/**
* @return the ySize
*/
public int getySize() {
return ySize;
}
/**
* @param ySize
* the ySize to set
*/
public void setySize(int ySize) {
this.ySize = ySize;
}
/**
* @param x
* @param y
*/
protected void drawToolTip() {
int x = Mouse.getEventX() * this.width / this.mc.displayWidth;
int y = this.height - Mouse.getEventY() * this.height
/ this.mc.displayHeight - 1;
List<String> tooltip = getToolTip(x, y);
if (tooltip != null) {
int strwidth = 0;
for (String s : tooltip) {
int currstrwidth = getFontRenderer().getStringWidth(s);
if (currstrwidth > strwidth) {
strwidth = currstrwidth;
}
}
MuseRenderer.drawGradientRect(
x, y - 10 * tooltip.size() - 5,
x + 10 + strwidth, y + 5,
new Colour(0.2F, 0.6F, 0.9F, 0.7F),
new Colour(0.1F, 0.3F, 0.4F, 0.7F),
0.0F);
RenderHelper.disableStandardItemLighting();
Colour fontcolour = new Colour(0.9F, 0.6F, 0.2F, 1.0F);
for (int i = 0; i < tooltip.size(); i++) {
this.getFontRenderer().drawStringWithShadow(tooltip.get(i),
x + 5,
y - 10 * (tooltip.size() - i), fontcolour.getInt());
}
}
}
/**
* @return
*/
protected List<String> getToolTip(int x, int y) {
return null;
}
/**
*
*/
public void refresh() {
}
}

13
machinemuse/powersuits/item/IModularItem.java
View file

@ -1,13 +0,0 @@
package machinemuse.powersuits.item;
import machinemuse.powersuits.common.Config;
/**
* Interface for ItemPowerArmor and ItemPowerTool to share.
*
* @author MachineMuse
*/
public interface IModularItem {
public Config.Items getItemType();
}

85
machinemuse/powersuits/item/ItemPowerArmor.java
View file

@ -1,85 +0,0 @@
package machinemuse.powersuits.item;
import machinemuse.powersuits.common.Config;
import machinemuse.powersuits.common.Config.Items;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.EnumArmorMaterial;
import net.minecraft.item.ItemArmor;
import net.minecraft.item.ItemStack;
import net.minecraft.util.DamageSource;
import net.minecraftforge.common.ISpecialArmor;
/**
* Describes the 4 different modular armor pieces - head, torso, legs, feet.
*
* @author MachineMuse
*/
public abstract class ItemPowerArmor extends ItemArmor
implements ISpecialArmor, IModularItem {
Config.Items itemType;
/**
* @param id
* @param material
* @param renderIndex
* @param armorType
* 0 = head; 1 = torso; 2 = legs; 3 = feet
*/
public ItemPowerArmor(int id, EnumArmorMaterial material,
int renderIndex, int armorType) {
super(id, material, renderIndex, armorType);
setMaxStackSize(1);
setCreativeTab(Config.getCreativeTab());
}
/**
* Inherited from ISpecialArmor, allows significant customization of damage
* calculations.
*/
@Override
public ArmorProperties getProperties(EntityLiving player, ItemStack armor,
DamageSource source, double damage, int slot) {
// Order in which this armor is assessed for damage. Higher(?) priority
// items take damage first, and if none spills over, the other items
// take no damage.
int priority = 1;
// How much of incoming damage is absorbed by this armor piece.
// 1.0 = absorbs all damage
// 0.5 = 50% damage to item, 50% damage carried over
double absorbRatio = 0.2;
// Maximum damage absorbed by this piece. Actual damage to this item
// will be clamped between (damage * absorbRatio) and (absorbMax). Note
// that a player has 20 hp (1hp = 1 half-heart)
int absorbMax = 4;
return new ArmorProperties(priority, absorbRatio,
absorbMax);
}
/**
* Inherited from ISpecialArmor, allows us to customize the calculations for
* how much armor will display on the player's HUD.
*/
@Override
public int getArmorDisplay(EntityPlayer player, ItemStack armor, int slot) {
return 4;
}
/**
* Inherited from ISpecialArmor, allows us to customize how the armor
* handles being damaged.
*/
@Override
public void damageArmor(EntityLiving entity, ItemStack stack,
DamageSource source, int damage, int slot) {
}
@Override
public Items getItemType() {
return itemType;
}
}

28
machinemuse/powersuits/item/ItemPowerArmorFeet.java
View file

@ -1,28 +0,0 @@
/**
*
*/
package machinemuse.powersuits.item;
import machinemuse.powersuits.common.Config;
import net.minecraft.item.EnumArmorMaterial;
import cpw.mods.fml.common.registry.LanguageRegistry;
/**
* @author MachineMuse
*
*/
public class ItemPowerArmorFeet extends ItemPowerArmor {
/**
* @param item
*/
public ItemPowerArmorFeet() {
super(Config.getAssignedItemID(Config.Items.PowerArmorFeet), // itemID
EnumArmorMaterial.IRON, // Material
0, // Texture index
3); // armor type. 0=head, 1=torso, 2=legs, 3=feet
itemType = Config.Items.PowerArmorFeet;
setItemName(itemType.idName);
LanguageRegistry.addName(this, itemType.englishName);
}
}

18
machinemuse/powersuits/item/ItemPowerArmorHead.java
View file

@ -1,18 +0,0 @@
package machinemuse.powersuits.item;
import machinemuse.powersuits.common.Config;
import net.minecraft.item.EnumArmorMaterial;
import cpw.mods.fml.common.registry.LanguageRegistry;
public class ItemPowerArmorHead extends ItemPowerArmor {
public ItemPowerArmorHead() {
super(Config.getAssignedItemID(Config.Items.PowerArmorHead), // itemID
EnumArmorMaterial.IRON, // Material
0, // Texture index
0); // armor type. 0=head, 1=torso, 2=legs, 3=feet
itemType = Config.Items.PowerArmorHead;
setItemName(itemType.idName);
LanguageRegistry.addName(this, itemType.englishName);
}
}

19
machinemuse/powersuits/item/ItemPowerArmorLegs.java
View file

@ -1,19 +0,0 @@
package machinemuse.powersuits.item;
import machinemuse.powersuits.common.Config;
import net.minecraft.item.EnumArmorMaterial;
import cpw.mods.fml.common.registry.LanguageRegistry;
public class ItemPowerArmorLegs extends ItemPowerArmor {
public ItemPowerArmorLegs() {
super(Config.getAssignedItemID(Config.Items.PowerArmorLegs), // itemID
EnumArmorMaterial.IRON, // Material
0, // Texture index
2); // armor type. 0=head, 1=torso, 2=legs, 3=feet
itemType = Config.Items.PowerArmorLegs;
setItemName(itemType.idName);
LanguageRegistry.addName(this, itemType.englishName);
}
}

19
machinemuse/powersuits/item/ItemPowerArmorTorso.java
View file

@ -1,19 +0,0 @@
package machinemuse.powersuits.item;
import machinemuse.powersuits.common.Config;
import net.minecraft.item.EnumArmorMaterial;
import cpw.mods.fml.common.registry.LanguageRegistry;
public class ItemPowerArmorTorso extends ItemPowerArmor {
public ItemPowerArmorTorso() {
super(Config.getAssignedItemID(Config.Items.PowerArmorTorso), // itemID
EnumArmorMaterial.IRON, // Material
0, // Texture index
1); // armor type.
itemType = Config.Items.PowerArmorTorso;
setItemName(itemType.idName);
LanguageRegistry.addName(this, itemType.englishName);
}
}

163
machinemuse/powersuits/item/ItemPowerTool.java
View file

@ -1,163 +0,0 @@
package machinemuse.powersuits.item;
import java.util.List;
import machinemuse.powersuits.common.Config;
import machinemuse.powersuits.common.Config.Items;
import net.minecraft.block.Block;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.item.EnumToolMaterial;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemTool;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeHooks;
import cpw.mods.fml.common.registry.LanguageRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/**
* Describes the modular power tool.
*
* @author MachineMuse
*/
public class ItemPowerTool extends ItemTool implements IModularItem {
protected List<String> validAugTypes;
/**
* Copied the comment for reference
*/
// /** Array of blocks the tool has extra effect against. */
// private Block[] blocksEffectiveAgainst;
// public float efficiencyOnProperMaterial = 4.0F;
//
// /** Damage versus entities. */
// public int damageVsEntity;
//
// /** The material this tool is made from. */
// protected EnumToolMaterial toolMaterial;
/**
* Constructor. Takes information from the Config.Items enum.
*/
public ItemPowerTool() {
super( // ID
Config.getAssignedItemID(Config.Items.PowerTool),
// Damage bonus, added to the material's damage
0,
// Tool material, can be changed if necessary
EnumToolMaterial.EMERALD,
// not important since it's private and we will override the
// getter
new Block[0] // Block[] BlocksEffectiveAgainst
);
setMaxStackSize(1);
setMaxDamage(0);
this.damageVsEntity = 1;
setCreativeTab(Config.getCreativeTab());
setIconIndex(Config.Items.PowerTool.iconIndex);
setItemName(Config.Items.PowerTool.idName);
LanguageRegistry.addName(this, Config.Items.PowerTool.englishName);
}
@Override
public Items getItemType() {
return Config.Items.PowerTool;
}
/**
* Returns the strength of the stack against a given block. 1.0F base,
* (Quality+1)*2 if correct blocktype, 1.5F if sword
*/
@Override
public float getStrVsBlock(ItemStack par1ItemStack, Block par2Block) {
// for (int var3 = 0; var3 < this.blocksEffectiveAgainst.length; ++var3)
// {
// if (this.blocksEffectiveAgainst[var3] == par2Block) {
// return this.efficiencyOnProperMaterial;
// }
// }
//
return 1.0F;
}
/**
* Current implementations of this method in child classes do not use the
* entry argument beside stack. They just raise the damage on the stack.
*/
@Override
public boolean hitEntity(ItemStack stack,
EntityLiving entityDoingHitting, EntityLiving entityBeingHit) {
// stack.damageItem(2, entityBeingHit);
return true;
}
/**
* Called when a block is destroyed using this tool.
*/
@Override
public boolean onBlockDestroyed(ItemStack stack, World world,
int blockID, int x, int y, int z,
EntityLiving par7EntityLiving) {
if (Block.blocksList[blockID]
.getBlockHardness(world, x, y, z) != 0.0D) {
stack.damageItem(1, par7EntityLiving);
}
return true;
}
/**
* Returns the damage against a given entity.
*/
@Override
public int getDamageVsEntity(Entity par1Entity) {
return 1;
}
@Override
@SideOnly(Side.CLIENT)
/**
* Returns True is the item is renderer in full 3D when hold.
*/
public boolean isFull3D() {
return true;
}
/**
* Return the enchantability factor of the item. In this case, 0. Might add
* an enchantability module later :P
*/
@Override
public int getItemEnchantability() {
return 0;
}
/**
* Return the name for this tool's material.
*/
@Override
public String getToolMaterialName() {
return this.toolMaterial.toString();
}
/**
* Return whether this item is repairable in an anvil.
*/
@Override
public boolean getIsRepairable(ItemStack par1ItemStack,
ItemStack par2ItemStack) {
return this.toolMaterial.getToolCraftingMaterial() == par2ItemStack.itemID ? true
: super.getIsRepairable(par1ItemStack, par2ItemStack);
}
/** FORGE: Overridden to allow custom tool effectiveness */
@Override
public float getStrVsBlock(ItemStack stack, Block block, int meta) {
if (ForgeHooks.isToolEffective(stack, block, meta)) {
return efficiencyOnProperMaterial;
}
return getStrVsBlock(stack, block);
}
}

186
machinemuse/powersuits/item/ItemUtils.java
View file

@ -1,186 +0,0 @@
package machinemuse.powersuits.item;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import machinemuse.powersuits.powermodule.PowerModule;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
public class ItemUtils {
/**
* Scans a specified inventory for modular items.
*
* @param inv
* IInventory to scan.
* @return A List of ItemStacks in the inventory which implement
* IModularItem
*/
public static List<ItemStack> getModularItemsInInventory(IInventory inv) {
ArrayList<ItemStack> stacks = new ArrayList<ItemStack>();
for (int i = 0; i < inv.getSizeInventory(); i++) {
ItemStack stack = inv.getStackInSlot(i);
if (stack != null && stack.getItem() instanceof IModularItem) {
stacks.add(stack);
}
}
return stacks;
}
/**
* Scans a specified inventory for modular items.
*
* @param inv
* IInventory to scan.
* @return A List of inventory slots containing an IModularItem
*/
public static List<Integer> getModularItemSlotsInInventory(IInventory inv) {
ArrayList<Integer> slots = new ArrayList<Integer>();
for (int i = 0; i < inv.getSizeInventory(); i++) {
ItemStack stack = inv.getStackInSlot(i);
if (stack != null && stack.getItem() instanceof IModularItem) {
slots.add(i);
}
}
return slots;
}
/**
* Attempts to cast an item to IModularItem, returns null if fails
*/
public static IModularItem getAsModular(Item item) {
if (item instanceof IModularItem) {
return (IModularItem) item;
} else {
return null;
}
}
/**
*
*
* @param player
* @return
*/
public static List<NBTTagCompound> getPlayerAugs(EntityPlayer player) {
List<NBTTagCompound> augs = new ArrayList<NBTTagCompound>();
List<ItemStack> items = getModularItemsInInventory(player.inventory);
Iterator<ItemStack> iter = items.iterator();
while (iter.hasNext()) {
NBTTagCompound itemAugs = PowerModule.getItemModules(iter.next());
for (Object ob : itemAugs.getTags()) {
if (ob instanceof NBTTagCompound) {
augs.add((NBTTagCompound) ob);
}
}
}
return augs;
}
/**
* @param next
* @return
*/
public static List<NBTTagCompound> getItemModulesWithPadding(ItemStack stack) {
List<PowerModule> validModules = PowerModule
.getValidModulesForItem(stack.getItem());
NBTTagCompound itemModule = PowerModule.getItemModules(stack);
List<NBTTagCompound> modulesList = new ArrayList<NBTTagCompound>();
for (PowerModule validModule : validModules) {
if (itemModule.hasKey(validModule.getName())) {
NBTTagCompound matchedAug = itemModule
.getCompoundTag(validModule
.getName());
modulesList.add(matchedAug);
} else {
NBTTagCompound newModule = validModule.newModuleTag();
modulesList.add(newModule);
itemModule.setCompoundTag(validModule.getName(), newModule);
}
}
return modulesList;
}
/**
* Checks if the player has a copy of all of the items in
* workingUpgradeCost.
*
* @param workingUpgradeCost
* @param inventory
* @return
*/
public static boolean hasInInventory(List<ItemStack> workingUpgradeCost,
InventoryPlayer inventory) {
for (int j = 0; j < workingUpgradeCost.size(); j++) {
ItemStack stackInCost = workingUpgradeCost.get(j);
int found = 0;
for (int i = 0; i < inventory.getSizeInventory(); i++) {
ItemStack stackInInventory = inventory.getStackInSlot(i);
if (stackInInventory != null) {
if (stackInInventory.itemID == stackInCost.itemID) {
found += stackInInventory.stackSize;
}
}
}
if (found < stackInCost.stackSize) {
return false;
}
}
return true;
}
/**
* @param workingUpgradeCost
* @param inventory
*/
public static List<Integer> deleteFromInventory(List<ItemStack> cost,
InventoryPlayer inventory) {
List<Integer> slots = new LinkedList<Integer>();
for (int j = 0; j < cost.size(); j++) {
ItemStack stackInCost = cost.get(j);
int remaining = stackInCost.stackSize;
for (int i = 0; i < inventory.getSizeInventory(); i++) {
ItemStack stackInInventory = inventory.getStackInSlot(i);
if (stackInInventory != null) {
if (stackInInventory.itemID == stackInCost.itemID) {
if (stackInInventory.stackSize > remaining) {
stackInInventory.stackSize -= remaining;
remaining = 0;
slots.add(i);
break;
} else {
remaining -= stackInInventory.stackSize;
inventory.setInventorySlotContents(i, null);
}
slots.add(i);
}
}
}
}
return slots;
}
/**
* Sums the weights of augmentations in the list.
*
* @param playerAugs
* @return
*/
public static float getTotalWeight(EntityPlayer player,
List<NBTTagCompound> playerAugs) {
float weight = 0;
for (NBTTagCompound aug : playerAugs) {
weight += PowerModule.getModuleFromNBT(aug).getWeight(player, aug);
}
return weight;
}
}

248
machinemuse/powersuits/network/MusePacket.java
View file

@ -1,248 +0,0 @@
/**
*
*/
package machinemuse.powersuits.network;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import machinemuse.powersuits.common.Config;
import machinemuse.powersuits.common.MuseLogger;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.CompressedStreamTools;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.packet.Packet250CustomPayload;
import cpw.mods.fml.common.network.Player;
/**
* @author MachineMuse
*
*/
public abstract class MusePacket {
protected static final int READ_ERROR = -150;
protected Player player;
protected ByteArrayOutputStream bytes;
protected Packet250CustomPayload packet;
protected DataOutputStream dataout;
protected DataInputStream datain;
protected int id;
protected MusePacket(Player player) {
this.player = player;
this.bytes = new ByteArrayOutputStream();
this.dataout = new DataOutputStream(bytes);
int id = MusePacketHandler.getTypeID(this);
writeInt(id);
}
private String listBytes(byte[] bytes) {
String s = "";
for (byte b : bytes) {
s = s + Byte.toString(b) + " ~ ";
}
return s;
}
protected MusePacket(Player player, DataInputStream data) {
this.player = player;
this.datain = data;
}
/**
* Gets the MC packet associated with this MusePacket
*
* @return Packet250CustomPayload
*/
public Packet250CustomPayload getPacket() {
byte[] output = bytes.toByteArray();
return new Packet250CustomPayload(Config.getNetworkChannelName(),
bytes.toByteArray());
}
/**
* Called by the network manager since it does all the packet mapping
*
* @param player2
*/
public abstract void handleClient(EntityClientPlayerMP player);
public abstract void handleServer(EntityPlayerMP player);
public int readInt() {
try {
int read = datain.readInt();
return read;
} catch (IOException e) {
MuseLogger.logError("PROBLEM WRITING INT TO PACKET D:");
e.printStackTrace();
return READ_ERROR;
}
}
public void writeInt(int i) {
try {
dataout.writeInt(i);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Reads a ItemStack from the InputStream
*/
public ItemStack readItemStack()
{
ItemStack stack = null;
try {
short itemID = datain.readShort();
if (itemID >= 0)
{
byte stackSize = datain.readByte();
short damageAmount = datain.readShort();
stack = new ItemStack(itemID, stackSize, damageAmount);
stack.stackTagCompound = readNBTTagCompound();
}
} catch (IOException e) {
MuseLogger.logError("Problem reading itemstack D:");
e.printStackTrace();
}
return stack;
}
/**
* Writes the ItemStack's ID (short), then size (byte), then damage. (short)
*/
public void writeItemStack(ItemStack stack)
{
try {
if (stack == null)
{
dataout.writeShort(-1);
}
else
{
dataout.writeShort(stack.itemID);
dataout.writeByte(stack.stackSize);
dataout.writeShort(stack.getItemDamage());
NBTTagCompound nbt = null;
if (stack.getItem().isDamageable()
|| stack.getItem().getShareTag())
{
nbt = stack.stackTagCompound;
}
writeNBTTagCompound(nbt);
}
} catch (IOException e) {
MuseLogger.logError("Problem writing itemstack D:");
e.printStackTrace();
}
}
/**
* Reads a compressed NBTTagCompound from the InputStream
*/
public NBTTagCompound readNBTTagCompound() throws IOException
{
short length = datain.readShort();
if (length < 0)
{
return null;
}
else
{
byte[] fullData = new byte[length];
datain.readFully(fullData);
return CompressedStreamTools.decompress(fullData);
}
}
/**
* Writes a compressed NBTTagCompound to the OutputStream
*/
protected void writeNBTTagCompound(
NBTTagCompound nbt) throws IOException
{
if (nbt == null)
{
dataout.writeShort(-1);
}
else
{
byte[] compressednbt = CompressedStreamTools.compress(nbt);
dataout.writeShort((short) compressednbt.length);
dataout.write(compressednbt);
}
}
/**
* Writes a String to the DataOutputStream
*/
public void writeString(String string)
{
try {
if (string.length() > 32767)
{
throw new IOException("String too big");
}
else
{
dataout.writeShort(string.length());
dataout.writeChars(string);
}
} catch (IOException e) {
MuseLogger.logError("String too big D:");
e.printStackTrace();
}
}
/**
* Reads a string from a packet
*/
public String readString(int maxlength)
{
try {
short length = datain.readShort();
if (length > maxlength)
{
throw new IOException(
"Received string length longer than maximum allowed ("
+ length + " > " + maxlength + ")");
}
else if (length < 0)
{
throw new IOException(
"Received string length is less than zero! Weird string!");
}
else
{
StringBuilder builder = new StringBuilder();
for (int i = 0; i < length; ++i)
{
builder.append(datain.readChar());
}
return builder.toString();
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}

161
machinemuse/powersuits/network/MusePacketHandler.java
View file

@ -1,161 +0,0 @@
/**
*
*/
package machinemuse.powersuits.network;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import machinemuse.powersuits.common.Config;
import machinemuse.powersuits.common.MuseLogger;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.network.INetworkManager;
import net.minecraft.network.packet.Packet250CustomPayload;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.network.IPacketHandler;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.network.Player;
import cpw.mods.fml.relauncher.Side;
/**
* @author MachineMuse
*
*/
public class MusePacketHandler implements IPacketHandler {
public MusePacketHandler register() {
addPacketType(1, MusePacketUpgradeRequest.class);
addPacketType(2, MusePacketInventoryRefresh.class);
NetworkRegistry.instance().registerChannel(this,
Config.getNetworkChannelName());
return this;
}
public static BiMap<Integer, Constructor<? extends MusePacket>> packetConstructors = HashBiMap
.create();
@Override
public void onPacketData(INetworkManager manager,
Packet250CustomPayload payload, Player player) {
if (payload.channel.equals(Config.getNetworkChannelName())) {
MusePacket repackaged = repackage(payload, player);
if (repackaged != null) {
Side side = FMLCommonHandler.instance().getEffectiveSide();
if (side == Side.CLIENT) {
repackaged.handleClient((EntityClientPlayerMP) player);
} else if (side == Side.SERVER) {
repackaged.handleServer((EntityPlayerMP) player);
}
}
}
}
public static MusePacket repackage(Packet250CustomPayload payload,
Player player) {
MusePacket repackaged = null;
DataInputStream data = new DataInputStream(new ByteArrayInputStream(
payload.data));
EntityPlayer target = (EntityPlayer) player;
int packetType;
try {
packetType = data.readInt();
repackaged = useConstructor(packetConstructors.get(packetType),
data, player);
} catch (IOException e) {
MuseLogger.logError("PROBLEM READING PACKET TYPE D:");
e.printStackTrace();
return null;
}
return repackaged;
}
/**
* @param type
* @return
*/
public static int getTypeID(MusePacket packet) {
try {
return packetConstructors.inverse().get(
getConstructor(packet.getClass()));
} catch (NoSuchMethodException e) {
MuseLogger.logError("INVALID PACKET CONSTRUCTOR D:");
e.printStackTrace();
} catch (SecurityException e) {
MuseLogger.logError("PACKET SECURITY PROBLEM D:");
e.printStackTrace();
}
return -150;
}
/**
* Returns the constructor of the given object. Keep in sync with
* useConstructor.
*
* @param packetType
* @return
* @throws NoSuchMethodException
* @throws SecurityException
*/
protected static Constructor<? extends MusePacket> getConstructor(
Class<? extends MusePacket> packetType)
throws NoSuchMethodException, SecurityException {
return packetType.getConstructor(DataInputStream.class, Player.class);
}
/**
* Returns a new instance of the object, created via the constructor in
* question. Keep in sync with getConstructor.
*
* @param constructor
* @return
*/
protected static MusePacket useConstructor(
Constructor<? extends MusePacket> constructor,
DataInputStream data, Player player) {
try {
return constructor.newInstance(data, player);
} catch (InstantiationException e) {
MuseLogger.logError("PROBLEM INSTATIATING PACKET D:");
e.printStackTrace();
} catch (IllegalAccessException e) {
MuseLogger.logError("PROBLEM ACCESSING PACKET D:");
e.printStackTrace();
} catch (IllegalArgumentException e) {
MuseLogger.logError("INVALID PACKET CONSTRUCTOR D:");
e.printStackTrace();
} catch (InvocationTargetException e) {
MuseLogger.logError("PROBLEM INVOKING PACKET CONSTRUCTOR D:");
e.printStackTrace();
}
return null;
}
public static boolean addPacketType(int id,
Class<? extends MusePacket> packetType) {
try {
// Add constructor to the list
packetConstructors.put(id, getConstructor(packetType));
return true;
} catch (NoSuchMethodException e) {
MuseLogger.logError("UNABLE TO REGISTER PACKET TYPE: "
+ packetType + ": INVALID CONSTRUCTOR");
e.printStackTrace();
} catch (SecurityException e) {
MuseLogger.logError("UNABLE TO REGISTER PACKET TYPE: "
+ packetType + ": SECURITY PROBLEM");
e.printStackTrace();
}
return false;
}
}

67
machinemuse/powersuits/network/MusePacketInventoryRefresh.java
View file

@ -1,67 +0,0 @@
/**
*
*/
package machinemuse.powersuits.network;
import java.io.DataInputStream;
import machinemuse.powersuits.common.MuseLogger;
import machinemuse.powersuits.gui.MuseGui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import cpw.mods.fml.common.network.Player;
/**
* @author MachineMuse
*
*/
public class MusePacketInventoryRefresh extends MusePacket {
protected ItemStack stack;
protected int slot;
/**
* @param player
*/
public MusePacketInventoryRefresh(Player player, int slot,
ItemStack stack) {
super(player);
writeInt(slot);
writeItemStack(stack);
}
/**
* @param player
* @param data
*/
public MusePacketInventoryRefresh(DataInputStream datain, Player player) {
super(player, datain);
slot = readInt();
stack = readItemStack();
}
/*
* (non-Javadoc)
*
* @see machinemuse.powersuits.network.MusePacket#handleSelf()
*/
@Override
public void handleClient(EntityClientPlayerMP player) {
IInventory inventory = player.inventory;
inventory.setInventorySlotContents(slot, stack);
MuseLogger.logDebug("Received slot " + slot);
GuiScreen playerscreen = Minecraft.getMinecraft().currentScreen;
if (playerscreen != null && playerscreen instanceof MuseGui) {
((MuseGui) playerscreen).refresh();
}
}
@Override
public void handleServer(EntityPlayerMP player) {
}
}

103
machinemuse/powersuits/network/MusePacketUpgradeRequest.java
View file

@ -1,103 +0,0 @@
/**
*
*/
package machinemuse.powersuits.network;
import java.io.DataInputStream;
import java.io.IOException;
import java.util.List;
import machinemuse.powersuits.item.ItemUtils;
import machinemuse.powersuits.powermodule.PowerModule;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.network.PacketDispatcher;
import cpw.mods.fml.common.network.Player;
import cpw.mods.fml.relauncher.Side;
/**
* Packet for requesting to purchase an upgrade. Player-to-server. Server
* decides whether it is a valid upgrade or not and replies with an associated
* inventoryrefresh packet.
*
* @author MachineMuse
*
*/
public class MusePacketUpgradeRequest extends MusePacket {
protected ItemStack stack;
protected int slot;
protected String moduleName;
/**
* Constructor for sending this packet.
*
* @param player
* Player making the request
* @param slotToUpgrade
* Slot containing the item for which the upgrade is requested
* @param augToUpgrade
*/
public MusePacketUpgradeRequest(Player player, int slotToUpgrade,
String augToUpgrade) {
super(player);
writeInt(slotToUpgrade);
writeString(augToUpgrade);
}
/**
* Constructor for receiving this packet.
*
* @param player
* @param data
* @throws IOException
*
*/
public MusePacketUpgradeRequest(DataInputStream data, Player player) {
super(player, data);
slot = readInt();
moduleName = readString(64);
Side side = FMLCommonHandler.instance().getEffectiveSide();
if (side == Side.SERVER) {
EntityPlayerMP srvplayer = (EntityPlayerMP) player;
stack = srvplayer.inventory.getStackInSlot(slot);
}
}
@Override
public void handleServer(EntityPlayerMP playerEntity) {
if (moduleName != null) {
InventoryPlayer inventory = playerEntity.inventory;
int entityId = playerEntity.entityId;
PowerModule moduleType = PowerModule.getModuleByID(moduleName);
NBTTagCompound moduleTag = PowerModule.getItemModules(stack)
.getCompoundTag(
moduleName);
List<ItemStack> cost = moduleType.getCost(playerEntity,
moduleTag);
if (ItemUtils.hasInInventory(cost, inventory)) {
List<Integer> slots = ItemUtils.deleteFromInventory(
cost, inventory);
moduleType.onUpgrade(playerEntity, moduleTag);
slots.add(this.slot);
for (Integer slotiter : slots) {
MusePacket reply = new MusePacketInventoryRefresh(
player,
slotiter, inventory.getStackInSlot(slotiter));
PacketDispatcher.sendPacketToPlayer(reply.getPacket(),
player);
}
}
}
}
@Override
public void handleClient(EntityClientPlayerMP player) {
// TODO Auto-generated method stub
}
}

309
machinemuse/powersuits/powermodule/PowerModule.java
View file

@ -1,309 +0,0 @@
/**
*
*/
package machinemuse.powersuits.powermodule;
import java.util.ArrayList;
import java.util.List;
import machinemuse.powersuits.common.MuseLogger;
import machinemuse.powersuits.item.ItemPowerArmor;
import machinemuse.powersuits.item.ItemPowerTool;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
/**
* PowerModule is the base class for the modules which can be installed in
* various power armor items.
*
* @author MachineMuse
*
*/
public abstract class PowerModule {
/**
* Contains constant strings. Mainly for consistency.
*
* @author MachineMuse
*/
public static final class Constants {
public static final String NAME = "Name";
public static final String MAXENERGY = "Maximum Energy";
public static final String CURRENERGY = "Current Energy";
public static final String LEVEL = "Level";
public static final String DURABILITY = "Durability";
public static final String nbtPrefix = "mmmpsmod";
}
/**
* Initialization for the module list
*/
static {
new PowerModuleIronPlating();
new PowerModuleBattery();
}
/**
* Module List
*/
public static BiMap<String, PowerModule> allModules = HashBiMap.create();
/**
* Module validity mappings. Slot 0-3 = armor, 4 = tool
*/
public static List<PowerModule>[] validModulesForSlot = new ArrayList[5];
/**
* Constructor adds the module to the appropriate lists.
*/
public PowerModule() {
for (int i = 0; i < 5; i++) {
if (validModulesForSlot[i] == null) {
validModulesForSlot[i] = new ArrayList();
}
if (getValidSlots()[i]) {
validModulesForSlot[i].add(this);
}
}
allModules.put(getName(), this);
}
/**
* Since modules themselves should be singletons, this is our instance
* pattern.
*
* @return A new NBTTagCompound describing a new instance of this module
* (pre-upgrade)
*/
public abstract NBTTagCompound newModuleTag();
/**
* Returns the name of the module. Should be unique. Used for both tooltips
* and for ID mapping.
*
* @return A string
*/
public abstract String getName();
/**
* Returns the weight of the module in kg. More than 25kg of equipment will
* start to slow a player down.
*
* @return Module's weight in kg
*/
public abstract float getWeight(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Returns the current upgrade level of the module based on the nbttag.
* Level 0 modules should do nothing.
*
* @return Module's weight in kg
*/
public int getLevel(
EntityPlayer player, NBTTagCompound moduleTag) {
return moduleTag.getInteger(Constants.LEVEL);
}
/**
* Returns the maximum level of the upgrade. If the upgrade's level is equal
* or greater, further upgrades will not be allowed.
*
* @return
*/
public abstract int getMaxLevel(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Returns the current armor value provided by the module.
*
* @return
*/
public abstract int getArmorValue(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Returns the lines of text to appear in the module's tooltip in the
* tinkertable UI.
*
* @return
*/
public abstract List<String> getTooltip(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Returns the list of itemstacks a player should receive if they uninstall
* this module.
*
* @return
*/
public abstract List<ItemStack> getRefund(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Returns the list of itemstacks required to upgrade this module.
*
* @return
*/
public abstract List<ItemStack> getCost(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Returns the a list of modules which must be purchased before this one
* will be available. Can be different depending on level.
*
* @return
*/
public abstract List<PowerModule> getPrerequisites(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Returns an array of booleans, one for each possible itemslot, describing
* whether or not the module can be slotted in that item.
*
* @return
*/
public abstract boolean[] getValidSlots();
/**
* Returns a category name for the module. Modules with the same category
* will be grouped together in the UI.
*
* @return
*/
public abstract String getCategory();
/**
* Event trigger in the player tick.
*/
public abstract void onPlayerTick(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Event trigger when the item is assigned durability damage.
*
* @param player
* @param moduleTag
* @param damageAmount
*/
public abstract void onDamageItem(
EntityPlayer player, NBTTagCompound moduleTag, float damageAmount);
/**
* Event trigger for when the item is upgraded. Should include leveling up.
*
* @param player
* @param moduleTag
* @return
*/
public abstract boolean onUpgrade(
EntityPlayer player, NBTTagCompound moduleTag);
/**
* Texture file for the module in GUI.
*
* @return
*/
public String getIconFile() {
return "/moduleicons.png";
}
/**
* Texture file for the module when slotted in an item.
*
* @return
*/
public String getItemOverlayFile() {
return "/moduleoverlays.png";
}
/**
* Index in the 256p*256p icon file. Indices go like this:
*
* <pre>
* 0 1 2 3 ...
* 16 18 19 20 ...
* 32 33 34 35 ...
* </pre>
*
* @return
*/
public abstract int getIconIndex();
/**
* Index in the item overlay file, same convention as icon index
*
* @return
*/
public abstract int getItemOverlayIndex();
/**
*
*
* @param next
* @return
*/
public static NBTTagCompound getItemModules(ItemStack stack) {
NBTTagCompound augs = null;
if (stack.hasTagCompound()) {
NBTTagCompound stackTag = stack.getTagCompound();
if (stackTag.hasKey(Constants.nbtPrefix)) {
augs = stackTag.getCompoundTag(Constants.nbtPrefix);
} else {
augs = new NBTTagCompound();
stackTag.setCompoundTag(Constants.nbtPrefix, augs);
}
} else {
NBTTagCompound stackTag = new NBTTagCompound();
stack.setTagCompound(stackTag);
augs = new NBTTagCompound();
stackTag.setCompoundTag(Constants.nbtPrefix, augs);
}
return augs;
}
public static void addModule(String id, PowerModule p) {
if (allModules.containsKey(id)) {
MuseLogger.logError("Warning: module " + p.getName()
+ " already bound!");
}
allModules.put(id, p);
}
public static PowerModule getModuleByID(String i) {
if (allModules.containsKey(i)) {
return allModules.get(i);
} else {
MuseLogger.logError("Module " + i + " not assigned!");
return null;
}
}
public static PowerModule getModuleFromNBT(NBTTagCompound moduleTag) {
return getModuleByID(moduleTag.getString("Name"));
}
public static String getModuleID(PowerModule module) {
if (allModules.inverse().containsKey(module)) {
return allModules.inverse().get(module);
} else {
MuseLogger.logError("Module " + module.getName()
+ " not initialized!");
return "";
}
}
public static List<PowerModule> getValidModulesForItem(Item item) {
if (item instanceof ItemPowerArmor) {
ItemPowerArmor itema = (ItemPowerArmor) item;
return validModulesForSlot[itema.armorType];
} else if (item instanceof ItemPowerTool) {
return validModulesForSlot[4];
} else {
return null;
}
}
}

129
machinemuse/powersuits/powermodule/PowerModuleBattery.java
View file

@ -1,129 +0,0 @@
package machinemuse.powersuits.powermodule;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
public class PowerModuleBattery extends PowerModule {
@Override
public NBTTagCompound newModuleTag() {
NBTTagCompound newtag = new NBTTagCompound();
newtag.setString("Name", getName());
newtag.setFloat("Maximum Energy", 100f);
newtag.setFloat("Current Energy", 100f);
newtag.setInteger("Level", 0);
return newtag;
}
@Override
public String getName() {
return "Electric Battery";
}
@Override
public float getWeight(EntityPlayer player, NBTTagCompound moduleTag) {
return 10;
}
@Override
public int getLevel(EntityPlayer player, NBTTagCompound moduleTag) {
return moduleTag.getInteger("Level");
}
@Override
public int getMaxLevel(EntityPlayer player, NBTTagCompound moduleTag) {
return 4;
}
@Override
public int getArmorValue(EntityPlayer player, NBTTagCompound moduleTag) {
return getLevel(player, moduleTag);
}
@Override
public List<String> getTooltip(EntityPlayer player, NBTTagCompound moduleTag) {
String[] strings = { getName(), "Battery" };
return Arrays.asList(strings);
}
@Override
public List<ItemStack> getRefund(EntityPlayer player,
NBTTagCompound moduleTag) {
List<ItemStack> stacks = new ArrayList<ItemStack>();
stacks.add(new ItemStack(Item.redstone,
(getLevel(player, moduleTag) + 1) * 4));
return stacks;
}
@Override
public List<ItemStack> getCost(EntityPlayer player, NBTTagCompound moduleTag) {
List<ItemStack> stacks = new ArrayList<ItemStack>();
stacks.add(new ItemStack(Item.redstone,
(getLevel(player, moduleTag) + 1) * 4));
return stacks;
}
@Override
public List<PowerModule> getPrerequisites(EntityPlayer player,
NBTTagCompound moduleTag) {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean[] getValidSlots() {
boolean[] slots = { true, true, true, true, true };
return slots;
}
@Override
public String getCategory() {
return "Energy";
}
@Override
public void onPlayerTick(EntityPlayer player, NBTTagCompound moduleTag) {
/** Do nothing **/
}
@Override
public void onDamageItem(EntityPlayer player, NBTTagCompound moduleTag,
float damageAmount) {
/** Do nothing **/
}
@Override
public boolean onUpgrade(EntityPlayer player, NBTTagCompound moduleTag) {
int level = moduleTag.getInteger("Level");
if (level < getMaxLevel(player, moduleTag)) {
moduleTag.setInteger("Level", level + 1);
return true;
} else {
return false;
}
}
@Override
public int getIconIndex() {
return 0;
}
@Override
public int getItemOverlayIndex() {
return 0;
}
public float getStoredEnergy(EntityPlayer player, NBTTagCompound batteryTag) {
return batteryTag.getFloat("Current Energy");
}
public float getMaxEnergy(EntityPlayer player, NBTTagCompound batteryTag) {
return batteryTag.getFloat("Maximum Energy");
}
}

122
machinemuse/powersuits/powermodule/PowerModuleIronPlating.java
View file

@ -1,122 +0,0 @@
package machinemuse.powersuits.powermodule;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
public class PowerModuleIronPlating extends PowerModule {
@Override
public NBTTagCompound newModuleTag() {
NBTTagCompound newtag = new NBTTagCompound();
newtag.setString("Name", getName());
newtag.setFloat("Durability", 100f);
newtag.setInteger("Level", 0);
return newtag;
}
@Override
public String getName() {
return "Iron Armor Plating";
}
@Override
public float getWeight(EntityPlayer player, NBTTagCompound moduleTag) {
return 10;
}
@Override
public int getLevel(EntityPlayer player, NBTTagCompound moduleTag) {
return moduleTag.getInteger("Level");
}
@Override
public int getMaxLevel(EntityPlayer player, NBTTagCompound moduleTag) {
return 4;
}
@Override
public int getArmorValue(EntityPlayer player, NBTTagCompound moduleTag) {
return getLevel(player, moduleTag);
}
@Override
public List<String> getTooltip(EntityPlayer player, NBTTagCompound moduleTag) {
String[] strings = { "Hi", "Module" };
return Arrays.asList(strings);
}
@Override
public List<ItemStack> getRefund(EntityPlayer player,
NBTTagCompound moduleTag) {
List<ItemStack> stacks = new ArrayList<ItemStack>();
stacks.add(new ItemStack(Item.redstone,
(getLevel(player, moduleTag) + 1) * 4));
return stacks;
}
@Override
public List<ItemStack> getCost(EntityPlayer player, NBTTagCompound moduleTag) {
List<ItemStack> stacks = new ArrayList<ItemStack>();
stacks.add(new ItemStack(Item.redstone,
(getLevel(player, moduleTag) + 1) * 4));
return stacks;
}
@Override
public List<PowerModule> getPrerequisites(EntityPlayer player,
NBTTagCompound moduleTag) {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean[] getValidSlots() {
boolean[] slots = { true, true, true, true, false };
return slots;
}
@Override
public String getCategory() {
return "Defense";
}
@Override
public void onPlayerTick(EntityPlayer player, NBTTagCompound moduleTag) {
/** Do nothing **/
}
@Override
public void onDamageItem(EntityPlayer player, NBTTagCompound moduleTag,
float damageAmount) {
float durability = moduleTag.getFloat("Durability");
moduleTag.setFloat("Durability", durability - damageAmount);
}
@Override
public boolean onUpgrade(EntityPlayer player, NBTTagCompound moduleTag) {
int level = moduleTag.getInteger("Level");
if (level < getMaxLevel(player, moduleTag)) {
moduleTag.setInteger("Level", level + 1);
return true;
} else {
return false;
}
}
@Override
public int getIconIndex() {
return 0;
}
@Override
public int getItemOverlayIndex() {
return 0;
}
}