Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "private", "String", "inClause", "(", "String", "field", ",", "Set", "<", "String", ">", "values", ")", "{", "String", "separator", "=", "\"\"", ";", "StringBuffer", "sb", "=", "new", "StringBuffer", "(", "\" and (\"", ")", ";", "for", "(", "String", "v", ":", "values", ")", "{", "sb", ".", "append", "(", "separator", ")", ";", "sb", ".", "append", "(", "String", ".", "format", "(", "\"%s = '%s'\"", ",", "field", ",", "v", ")", ")", ";", "separator", "=", "\" or \"", ";", "}", "sb", ".", "append", "(", "\")\"", ")", ";", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "An", "exploded", "in", "clause", "because", "the", "actual", "one", "seems", "not", "to", "work" ]

[ "public", "String", "rfc5988String", "(", ")", "{", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ";", "builder", ".", "append", "(", "\"<\"", ")", ".", "append", "(", "href", ")", ".", "append", "(", "\">; rel=\\\"\"", ")", ".", "append", "(", "rel", ")", ".", "append", "(", "\"\\\"\"", ")", ";", "return", "builder", ".", "toString", "(", ")", ";", "}" ]

[ "Return", "the", "link", "in", "the", "format", "of", "RFC", "5988", "Web", "Linking", "." ]

[ "public", "String", "cleanWithOutputEncoding", "(", "String", "input", ",", "String", "outputEncoding", ")", "throws", "ConversionException", "{", "return", "clean", "(", "input", ",", "null", ",", "outputEncoding", ")", ";", "}" ]

[ "Clean", "-", "up", "HTML", "code", "with", "specified", "output", "encoding", "asumes", "UTF", "-", "8", "as", "input", "encoding", "." ]

[ "public", "String", "cleanWithInputEncoding", "(", "String", "htmlFile", ",", "String", "inputEncoding", ")", "throws", "ConversionException", "{", "return", "clean", "(", "htmlFile", ",", "inputEncoding", ",", "null", ")", ";", "}" ]

[ "Clean", "-", "up", "HTML", "code", "with", "specified", "input", "encoding", "asumes", "UTF", "-", "8", "as", "output", "encoding", "." ]

[ "public", "String", "clean", "(", "String", "input", ",", "String", "inputEncoding", ",", "String", "outputEncoding", ")", "throws", "ConversionException", "{", "InputStream", "stringAsStream", ";", "try", "{", "stringAsStream", "=", "new", "ByteArrayInputStream", "(", "input", ".", "getBytes", "(", "inputEncoding", "!=", "null", "?", "inputEncoding", ":", "\"UTF-8\"", ")", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "ConversionException", ".", "HTML_TO_PDF_EXCEPTION", ";", "}", "ByteArrayOutputStream", "outputAsStream", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "Tidy", "htmlCleaner", "=", "new", "Tidy", "(", ")", ";", "htmlCleaner", ".", "setInputEncoding", "(", "inputEncoding", "!=", "null", "?", "inputEncoding", ":", "\"UTF-8\"", ")", ";", "htmlCleaner", ".", "setOutputEncoding", "(", "outputEncoding", "!=", "null", "?", "outputEncoding", ":", "\"UTF-8\"", ")", ";", "htmlCleaner", ".", "setXHTML", "(", "true", ")", ";", "htmlCleaner", ".", "parse", "(", "stringAsStream", ",", "outputAsStream", ")", ";", "try", "{", "String", "result", "=", "outputAsStream", ".", "toString", "(", "outputEncoding", "!=", "null", "?", "outputEncoding", ":", "\"UTF-8\"", ")", ";", "return", "result", ".", "trim", "(", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "ConversionException", ".", "HTML_TO_PDF_EXCEPTION", ";", "}", "}" ]

[ "Clean", "-", "up", "HTML", "code", "with", "specified", "input", "and", "output", "encodings", "." ]

[ "public", "static", "void", "setCurrent", "(", "Graphics", "current", ")", "{", "if", "(", "currentGraphics", "!=", "current", ")", "{", "if", "(", "currentGraphics", "!=", "null", ")", "{", "currentGraphics", ".", "disable", "(", ")", ";", "}", "currentGraphics", "=", "current", ";", "currentGraphics", ".", "enable", "(", ")", ";", "}", "}" ]

[ "Set", "the", "current", "graphics", "context", "in", "use" ]

[ "public", "void", "setDrawMode", "(", "int", "mode", ")", "{", "predraw", "(", ")", ";", "currentDrawingMode", "=", "mode", ";", "if", "(", "currentDrawingMode", "==", "MODE_NORMAL", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_BLEND", ")", ";", "GL", ".", "glColorMask", "(", "true", ",", "true", ",", "true", ",", "true", ")", ";", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_SRC_ALPHA", ",", "SGL", ".", "GL_ONE_MINUS_SRC_ALPHA", ")", ";", "}", "if", "(", "currentDrawingMode", "==", "MODE_ALPHA_MAP", ")", "{", "GL", ".", "glDisable", "(", "SGL", ".", "GL_BLEND", ")", ";", "GL", ".", "glColorMask", "(", "false", ",", "false", ",", "false", ",", "true", ")", ";", "}", "if", "(", "currentDrawingMode", "==", "MODE_ALPHA_BLEND", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_BLEND", ")", ";", "GL", ".", "glColorMask", "(", "true", ",", "true", ",", "true", ",", "false", ")", ";", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_DST_ALPHA", ",", "SGL", ".", "GL_ONE_MINUS_DST_ALPHA", ")", ";", "}", "if", "(", "currentDrawingMode", "==", "MODE_COLOR_MULTIPLY", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_BLEND", ")", ";", "GL", ".", "glColorMask", "(", "true", ",", "true", ",", "true", ",", "true", ")", ";", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_ONE_MINUS_SRC_COLOR", ",", "SGL", ".", "GL_SRC_COLOR", ")", ";", "}", "if", "(", "currentDrawingMode", "==", "MODE_ADD", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_BLEND", ")", ";", "GL", ".", "glColorMask", "(", "true", ",", "true", ",", "true", ",", "true", ")", ";", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_ONE", ",", "SGL", ".", "GL_ONE", ")", ";", "}", "if", "(", "currentDrawingMode", "==", "MODE_SCREEN", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_BLEND", ")", ";", "GL", ".", "glColorMask", "(", "true", ",", "true", ",", "true", ",", "true", ")", ";", "GL", ".", "glBlendFunc", "(", "SGL", ".", "GL_ONE", ",", "SGL", ".", "GL_ONE_MINUS_SRC_COLOR", ")", ";", "}", "postdraw", "(", ")", ";", "}" ]

[ "Set", "the", "drawing", "mode", "to", "use", ".", "This", "mode", "defines", "how", "pixels", "are", "drawn", "to", "the", "graphics", "context", ".", "It", "can", "be", "used", "to", "draw", "into", "the", "alpha", "map", "." ]

[ "public", "void", "setBackground", "(", "Color", "color", ")", "{", "predraw", "(", ")", ";", "GL", ".", "glClearColor", "(", "color", ".", "r", ",", "color", ".", "g", ",", "color", ".", "b", ",", "color", ".", "a", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Set", "the", "background", "colour", "of", "the", "graphics", "context", ".", "This", "colour", "is", "used", "when", "clearing", "the", "context", ".", "Note", "that", "calling", "this", "method", "alone", "does", "not", "cause", "the", "context", "to", "be", "cleared", "." ]

[ "public", "Color", "getBackground", "(", ")", "{", "predraw", "(", ")", ";", "FloatBuffer", "buffer", "=", "BufferUtils", ".", "createFloatBuffer", "(", "16", ")", ";", "GL", ".", "glGetFloat", "(", "SGL", ".", "GL_COLOR_CLEAR_VALUE", ",", "buffer", ")", ";", "postdraw", "(", ")", ";", "return", "new", "Color", "(", "buffer", ")", ";", "}" ]

[ "Get", "the", "current", "graphics", "context", "background", "color" ]

[ "public", "void", "resetTransform", "(", ")", "{", "sx", "=", "1", ";", "sy", "=", "1", ";", "if", "(", "pushed", ")", "{", "predraw", "(", ")", ";", "GL", ".", "glPopMatrix", "(", ")", ";", "pushed", "=", "false", ";", "postdraw", "(", ")", ";", "}", "}" ]

[ "Reset", "the", "transformation", "on", "this", "graphics", "context" ]

[ "public", "void", "scale", "(", "float", "sx", ",", "float", "sy", ")", "{", "this", ".", "sx", "=", "this", ".", "sx", "*", "sx", ";", "this", ".", "sy", "=", "this", ".", "sy", "*", "sy", ";", "checkPush", "(", ")", ";", "predraw", "(", ")", ";", "GL", ".", "glScalef", "(", "sx", ",", "sy", ",", "1", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Apply", "a", "scaling", "factor", "to", "everything", "drawn", "on", "the", "graphics", "context" ]

[ "public", "void", "rotate", "(", "float", "rx", ",", "float", "ry", ",", "float", "ang", ")", "{", "checkPush", "(", ")", ";", "predraw", "(", ")", ";", "translate", "(", "rx", ",", "ry", ")", ";", "GL", ".", "glRotatef", "(", "ang", ",", "0", ",", "0", ",", "1", ")", ";", "translate", "(", "-", "rx", ",", "-", "ry", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Apply", "a", "rotation", "to", "everything", "draw", "on", "the", "graphics", "context" ]

[ "public", "void", "translate", "(", "float", "x", ",", "float", "y", ")", "{", "checkPush", "(", ")", ";", "predraw", "(", ")", ";", "GL", ".", "glTranslatef", "(", "x", ",", "y", ",", "0", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Apply", "a", "translation", "to", "everything", "drawn", "to", "the", "context" ]

[ "public", "void", "setColor", "(", "Color", "color", ")", "{", "if", "(", "color", "==", "null", ")", "{", "return", ";", "}", "currentColor", "=", "new", "Color", "(", "color", ")", ";", "predraw", "(", ")", ";", "currentColor", ".", "bind", "(", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Set", "the", "color", "to", "use", "when", "rendering", "to", "this", "context" ]

[ "public", "void", "drawLine", "(", "float", "x1", ",", "float", "y1", ",", "float", "x2", ",", "float", "y2", ")", "{", "float", "lineWidth", "=", "this", ".", "lineWidth", "-", "1", ";", "if", "(", "LSR", ".", "applyGLLineFixes", "(", ")", ")", "{", "if", "(", "x1", "==", "x2", ")", "{", "if", "(", "y1", ">", "y2", ")", "{", "float", "temp", "=", "y2", ";", "y2", "=", "y1", ";", "y1", "=", "temp", ";", "}", "float", "step", "=", "1", "/", "sy", ";", "lineWidth", "=", "lineWidth", "/", "sy", ";", "fillRect", "(", "x1", "-", "(", "lineWidth", "/", "2.0f", ")", ",", "y1", "-", "(", "lineWidth", "/", "2.0f", ")", ",", "lineWidth", "+", "step", ",", "(", "y2", "-", "y1", ")", "+", "lineWidth", "+", "step", ")", ";", "return", ";", "}", "else", "if", "(", "y1", "==", "y2", ")", "{", "if", "(", "x1", ">", "x2", ")", "{", "float", "temp", "=", "x2", ";", "x2", "=", "x1", ";", "x1", "=", "temp", ";", "}", "float", "step", "=", "1", "/", "sx", ";", "lineWidth", "=", "lineWidth", "/", "sx", ";", "fillRect", "(", "x1", "-", "(", "lineWidth", "/", "2.0f", ")", ",", "y1", "-", "(", "lineWidth", "/", "2.0f", ")", ",", "(", "x2", "-", "x1", ")", "+", "lineWidth", "+", "step", ",", "lineWidth", "+", "step", ")", ";", "return", ";", "}", "}", "predraw", "(", ")", ";", "currentColor", ".", "bind", "(", ")", ";", "TextureImpl", ".", "bindNone", "(", ")", ";", "LSR", ".", "start", "(", ")", ";", "LSR", ".", "vertex", "(", "x1", ",", "y1", ")", ";", "LSR", ".", "vertex", "(", "x2", ",", "y2", ")", ";", "LSR", ".", "end", "(", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Draw", "a", "line", "on", "the", "canvas", "in", "the", "current", "colour" ]

[ "public", "void", "draw", "(", "Shape", "shape", ",", "ShapeFill", "fill", ")", "{", "predraw", "(", ")", ";", "TextureImpl", ".", "bindNone", "(", ")", ";", "ShapeRenderer", ".", "draw", "(", "shape", ",", "fill", ")", ";", "currentColor", ".", "bind", "(", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Draw", "the", "outline", "of", "the", "given", "shape", "." ]

[ "public", "void", "drawRect", "(", "float", "x1", ",", "float", "y1", ",", "float", "width", ",", "float", "height", ")", "{", "float", "lineWidth", "=", "getLineWidth", "(", ")", ";", "drawLine", "(", "x1", ",", "y1", ",", "x1", "+", "width", ",", "y1", ")", ";", "drawLine", "(", "x1", "+", "width", ",", "y1", ",", "x1", "+", "width", ",", "y1", "+", "height", ")", ";", "drawLine", "(", "x1", "+", "width", ",", "y1", "+", "height", ",", "x1", ",", "y1", "+", "height", ")", ";", "drawLine", "(", "x1", ",", "y1", "+", "height", ",", "x1", ",", "y1", ")", ";", "}" ]

[ "Draw", "a", "rectangle", "to", "the", "canvas", "in", "the", "current", "colour" ]

[ "public", "void", "setWorldClip", "(", "float", "x", ",", "float", "y", ",", "float", "width", ",", "float", "height", ")", "{", "predraw", "(", ")", ";", "worldClipRecord", "=", "new", "Rectangle", "(", "x", ",", "y", ",", "width", ",", "height", ")", ";", "GL", ".", "glEnable", "(", "SGL", ".", "GL_CLIP_PLANE0", ")", ";", "worldClip", ".", "put", "(", "1", ")", ".", "put", "(", "0", ")", ".", "put", "(", "0", ")", ".", "put", "(", "-", "x", ")", ".", "flip", "(", ")", ";", "GL", ".", "glClipPlane", "(", "SGL", ".", "GL_CLIP_PLANE0", ",", "worldClip", ")", ";", "GL", ".", "glEnable", "(", "SGL", ".", "GL_CLIP_PLANE1", ")", ";", "worldClip", ".", "put", "(", "-", "1", ")", ".", "put", "(", "0", ")", ".", "put", "(", "0", ")", ".", "put", "(", "x", "+", "width", ")", ".", "flip", "(", ")", ";", "GL", ".", "glClipPlane", "(", "SGL", ".", "GL_CLIP_PLANE1", ",", "worldClip", ")", ";", "GL", ".", "glEnable", "(", "SGL", ".", "GL_CLIP_PLANE2", ")", ";", "worldClip", ".", "put", "(", "0", ")", ".", "put", "(", "1", ")", ".", "put", "(", "0", ")", ".", "put", "(", "-", "y", ")", ".", "flip", "(", ")", ";", "GL", ".", "glClipPlane", "(", "SGL", ".", "GL_CLIP_PLANE2", ",", "worldClip", ")", ";", "GL", ".", "glEnable", "(", "SGL", ".", "GL_CLIP_PLANE3", ")", ";", "worldClip", ".", "put", "(", "0", ")", ".", "put", "(", "-", "1", ")", ".", "put", "(", "0", ")", ".", "put", "(", "y", "+", "height", ")", ".", "flip", "(", ")", ";", "GL", ".", "glClipPlane", "(", "SGL", ".", "GL_CLIP_PLANE3", ",", "worldClip", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Set", "clipping", "that", "controls", "which", "areas", "of", "the", "world", "will", "be", "drawn", "to", ".", "Note", "that", "world", "clip", "is", "different", "from", "standard", "screen", "clip", "in", "that", "it", "s", "defined", "in", "the", "space", "of", "the", "current", "world", "coordinate", "-", "i", ".", "e", ".", "it", "s", "affected", "by", "translate", "rotate", "scale", "etc", "." ]

[ "public", "void", "clearWorldClip", "(", ")", "{", "predraw", "(", ")", ";", "worldClipRecord", "=", "null", ";", "GL", ".", "glDisable", "(", "SGL", ".", "GL_CLIP_PLANE0", ")", ";", "GL", ".", "glDisable", "(", "SGL", ".", "GL_CLIP_PLANE1", ")", ";", "GL", ".", "glDisable", "(", "SGL", ".", "GL_CLIP_PLANE2", ")", ";", "GL", ".", "glDisable", "(", "SGL", ".", "GL_CLIP_PLANE3", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Clear", "world", "clipping", "setup", ".", "This", "does", "not", "effect", "screen", "clipping" ]

[ "public", "void", "setWorldClip", "(", "Rectangle", "clip", ")", "{", "if", "(", "clip", "==", "null", ")", "{", "clearWorldClip", "(", ")", ";", "}", "else", "{", "setWorldClip", "(", "clip", ".", "getX", "(", ")", ",", "clip", ".", "getY", "(", ")", ",", "clip", ".", "getWidth", "(", ")", ",", "clip", ".", "getHeight", "(", ")", ")", ";", "}", "}" ]

[ "Set", "the", "world", "clip", "to", "be", "applied" ]

[ "public", "void", "fillRect", "(", "float", "x", ",", "float", "y", ",", "float", "width", ",", "float", "height", ",", "Image", "pattern", ",", "float", "offX", ",", "float", "offY", ")", "{", "int", "cols", "=", "(", "(", "int", ")", "Math", ".", "ceil", "(", "width", "/", "pattern", ".", "getWidth", "(", ")", ")", ")", "+", "2", ";", "int", "rows", "=", "(", "(", "int", ")", "Math", ".", "ceil", "(", "height", "/", "pattern", ".", "getHeight", "(", ")", ")", ")", "+", "2", ";", "Rectangle", "preClip", "=", "getWorldClip", "(", ")", ";", "setWorldClip", "(", "x", ",", "y", ",", "width", ",", "height", ")", ";", "predraw", "(", ")", ";", "// Draw all the quads we need\r", "for", "(", "int", "c", "=", "0", ";", "c", "<", "cols", ";", "c", "++", ")", "{", "for", "(", "int", "r", "=", "0", ";", "r", "<", "rows", ";", "r", "++", ")", "{", "pattern", ".", "draw", "(", "c", "*", "pattern", ".", "getWidth", "(", ")", "+", "x", "-", "offX", ",", "r", "*", "pattern", ".", "getHeight", "(", ")", "+", "y", "-", "offY", ")", ";", "}", "}", "postdraw", "(", ")", ";", "setWorldClip", "(", "preClip", ")", ";", "}" ]

[ "Tile", "a", "rectangle", "with", "a", "pattern", "specifing", "the", "offset", "from", "the", "top", "corner", "that", "one", "tile", "should", "match" ]

[ "public", "void", "fillRect", "(", "float", "x1", ",", "float", "y1", ",", "float", "width", ",", "float", "height", ")", "{", "predraw", "(", ")", ";", "TextureImpl", ".", "bindNone", "(", ")", ";", "currentColor", ".", "bind", "(", ")", ";", "GL", ".", "glBegin", "(", "SGL", ".", "GL_QUADS", ")", ";", "GL", ".", "glVertex2f", "(", "x1", ",", "y1", ")", ";", "GL", ".", "glVertex2f", "(", "x1", "+", "width", ",", "y1", ")", ";", "GL", ".", "glVertex2f", "(", "x1", "+", "width", ",", "y1", "+", "height", ")", ";", "GL", ".", "glVertex2f", "(", "x1", ",", "y1", "+", "height", ")", ";", "GL", ".", "glEnd", "(", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Fill", "a", "rectangle", "on", "the", "canvas", "in", "the", "current", "color" ]

[ "public", "void", "setLineWidth", "(", "float", "width", ")", "{", "predraw", "(", ")", ";", "this", ".", "lineWidth", "=", "width", ";", "LSR", ".", "setWidth", "(", "width", ")", ";", "GL", ".", "glPointSize", "(", "width", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Set", "the", "with", "of", "the", "line", "to", "be", "used", "when", "drawing", "line", "based", "primitives" ]

[ "public", "void", "resetLineWidth", "(", ")", "{", "predraw", "(", ")", ";", "Renderer", ".", "getLineStripRenderer", "(", ")", ".", "setWidth", "(", "1.0f", ")", ";", "GL", ".", "glLineWidth", "(", "1.0f", ")", ";", "GL", ".", "glPointSize", "(", "1.0f", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Reset", "the", "line", "width", "in", "use", "to", "the", "default", "for", "this", "graphics", "context" ]

[ "public", "void", "setAntiAlias", "(", "boolean", "anti", ")", "{", "predraw", "(", ")", ";", "antialias", "=", "anti", ";", "LSR", ".", "setAntiAlias", "(", "anti", ")", ";", "if", "(", "anti", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_POLYGON_SMOOTH", ")", ";", "}", "else", "{", "GL", ".", "glDisable", "(", "SGL", ".", "GL_POLYGON_SMOOTH", ")", ";", "}", "postdraw", "(", ")", ";", "}" ]

[ "Indicate", "if", "we", "should", "antialias", "as", "we", "draw", "primitives" ]

[ "public", "void", "drawString", "(", "String", "str", ",", "float", "x", ",", "float", "y", ")", "{", "predraw", "(", ")", ";", "font", ".", "drawString", "(", "x", ",", "y", ",", "str", ",", "currentColor", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Draw", "a", "string", "to", "the", "screen", "using", "the", "current", "font" ]

[ "public", "void", "copyArea", "(", "Image", "target", ",", "int", "x", ",", "int", "y", ")", "{", "int", "format", "=", "target", ".", "getTexture", "(", ")", ".", "hasAlpha", "(", ")", "?", "SGL", ".", "GL_RGBA", ":", "SGL", ".", "GL_RGB", ";", "target", ".", "bind", "(", ")", ";", "GL", ".", "glCopyTexImage2D", "(", "SGL", ".", "GL_TEXTURE_2D", ",", "0", ",", "format", ",", "x", ",", "screenHeight", "-", "(", "y", "+", "target", ".", "getHeight", "(", ")", ")", ",", "target", ".", "getTexture", "(", ")", ".", "getTextureWidth", "(", ")", ",", "target", ".", "getTexture", "(", ")", ".", "getTextureHeight", "(", ")", ",", "0", ")", ";", "target", ".", "ensureInverted", "(", ")", ";", "}" ]

[ "Copy", "an", "area", "of", "the", "rendered", "screen", "into", "an", "image", ".", "The", "width", "and", "height", "of", "the", "area", "are", "assumed", "to", "match", "that", "of", "the", "image" ]

[ "public", "Color", "getPixel", "(", "int", "x", ",", "int", "y", ")", "{", "predraw", "(", ")", ";", "GL", ".", "glReadPixels", "(", "x", ",", "screenHeight", "-", "y", ",", "1", ",", "1", ",", "SGL", ".", "GL_RGBA", ",", "SGL", ".", "GL_UNSIGNED_BYTE", ",", "readBuffer", ")", ";", "postdraw", "(", ")", ";", "return", "new", "Color", "(", "translate", "(", "readBuffer", ".", "get", "(", "0", ")", ")", ",", "translate", "(", "readBuffer", ".", "get", "(", "1", ")", ")", ",", "translate", "(", "readBuffer", ".", "get", "(", "2", ")", ")", ",", "translate", "(", "readBuffer", ".", "get", "(", "3", ")", ")", ")", ";", "}" ]

[ "Get", "the", "colour", "of", "a", "single", "pixel", "in", "this", "graphics", "context" ]

[ "public", "void", "getArea", "(", "int", "x", ",", "int", "y", ",", "int", "width", ",", "int", "height", ",", "ByteBuffer", "target", ")", "{", "if", "(", "target", ".", "capacity", "(", ")", "<", "width", "*", "height", "*", "4", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Byte buffer provided to get area is not big enough\"", ")", ";", "}", "predraw", "(", ")", ";", "GL", ".", "glReadPixels", "(", "x", ",", "screenHeight", "-", "y", "-", "height", ",", "width", ",", "height", ",", "SGL", ".", "GL_RGBA", ",", "SGL", ".", "GL_UNSIGNED_BYTE", ",", "target", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Get", "an", "ara", "of", "pixels", "as", "RGBA", "values", "into", "a", "buffer" ]

[ "public", "void", "popTransform", "(", ")", "{", "if", "(", "stackIndex", "==", "0", ")", "{", "throw", "new", "RuntimeException", "(", "\"Attempt to pop a transform that hasn't be pushed\"", ")", ";", "}", "predraw", "(", ")", ";", "stackIndex", "--", ";", "FloatBuffer", "oldBuffer", "=", "(", "FloatBuffer", ")", "stack", ".", "get", "(", "stackIndex", ")", ";", "GL", ".", "glLoadMatrix", "(", "oldBuffer", ")", ";", "sx", "=", "oldBuffer", ".", "get", "(", "16", ")", ";", "sy", "=", "oldBuffer", ".", "get", "(", "17", ")", ";", "postdraw", "(", ")", ";", "}" ]

[ "Pop", "a", "previously", "pushed", "transform", "from", "the", "stack", "to", "the", "current", ".", "This", "should", "only", "be", "called", "if", "a", "transform", "has", "been", "previously", "pushed", "." ]

[ "public", "int", "getLayerIndex", "(", "String", "name", ")", "{", "int", "idx", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "layers", ".", "size", "(", ")", ";", "i", "++", ")", "{", "Layer", "layer", "=", "(", "Layer", ")", "layers", ".", "get", "(", "i", ")", ";", "if", "(", "layer", ".", "name", ".", "equals", "(", "name", ")", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Get", "the", "index", "of", "the", "layer", "with", "given", "name" ]

[ "public", "Image", "getTileImage", "(", "int", "x", ",", "int", "y", ",", "int", "layerIndex", ")", "{", "Layer", "layer", "=", "(", "Layer", ")", "layers", ".", "get", "(", "layerIndex", ")", ";", "int", "tileSetIndex", "=", "layer", ".", "data", "[", "x", "]", "[", "y", "]", "[", "0", "]", ";", "if", "(", "(", "tileSetIndex", ">=", "0", ")", "&&", "(", "tileSetIndex", "<", "tileSets", ".", "size", "(", ")", ")", ")", "{", "TileSet", "tileSet", "=", "(", "TileSet", ")", "tileSets", ".", "get", "(", "tileSetIndex", ")", ";", "int", "sheetX", "=", "tileSet", ".", "getTileX", "(", "layer", ".", "data", "[", "x", "]", "[", "y", "]", "[", "1", "]", ")", ";", "int", "sheetY", "=", "tileSet", ".", "getTileY", "(", "layer", ".", "data", "[", "x", "]", "[", "y", "]", "[", "1", "]", ")", ";", "return", "tileSet", ".", "tiles", ".", "getSprite", "(", "sheetX", ",", "sheetY", ")", ";", "}", "return", "null", ";", "}" ]

[ "Gets", "the", "Image", "used", "to", "draw", "the", "tile", "at", "the", "given", "x", "and", "y", "coordinates", "." ]

[ "public", "int", "getTileId", "(", "int", "x", ",", "int", "y", ",", "int", "layerIndex", ")", "{", "Layer", "layer", "=", "(", "Layer", ")", "layers", ".", "get", "(", "layerIndex", ")", ";", "return", "layer", ".", "getTileID", "(", "x", ",", "y", ")", ";", "}" ]

[ "Get", "the", "global", "ID", "of", "a", "tile", "at", "specified", "location", "in", "the", "map" ]

[ "public", "void", "setTileId", "(", "int", "x", ",", "int", "y", ",", "int", "layerIndex", ",", "int", "tileid", ")", "{", "Layer", "layer", "=", "(", "Layer", ")", "layers", ".", "get", "(", "layerIndex", ")", ";", "layer", ".", "setTileID", "(", "x", ",", "y", ",", "tileid", ")", ";", "}" ]

[ "Set", "the", "global", "ID", "of", "a", "tile", "at", "specified", "location", "in", "the", "map" ]

[ "public", "String", "getMapProperty", "(", "String", "propertyName", ",", "String", "def", ")", "{", "if", "(", "props", "==", "null", ")", "return", "def", ";", "return", "props", ".", "getProperty", "(", "propertyName", ",", "def", ")", ";", "}" ]

[ "Get", "a", "property", "given", "to", "the", "map", ".", "Note", "that", "this", "method", "will", "not", "perform", "well", "and", "should", "not", "be", "used", "as", "part", "of", "the", "default", "code", "path", "in", "the", "game", "loop", "." ]

[ "public", "String", "getLayerProperty", "(", "int", "layerIndex", ",", "String", "propertyName", ",", "String", "def", ")", "{", "Layer", "layer", "=", "(", "Layer", ")", "layers", ".", "get", "(", "layerIndex", ")", ";", "if", "(", "layer", "==", "null", "||", "layer", ".", "props", "==", "null", ")", "return", "def", ";", "return", "layer", ".", "props", ".", "getProperty", "(", "propertyName", ",", "def", ")", ";", "}" ]

[ "Get", "a", "property", "given", "to", "a", "particular", "layer", ".", "Note", "that", "this", "method", "will", "not", "perform", "well", "and", "should", "not", "be", "used", "as", "part", "of", "the", "default", "code", "path", "in", "the", "game", "loop", "." ]

[ "public", "String", "getTileProperty", "(", "int", "tileID", ",", "String", "propertyName", ",", "String", "def", ")", "{", "if", "(", "tileID", "==", "0", ")", "{", "return", "def", ";", "}", "TileSet", "set", "=", "findTileSet", "(", "tileID", ")", ";", "Properties", "props", "=", "set", ".", "getProperties", "(", "tileID", ")", ";", "if", "(", "props", "==", "null", ")", "{", "return", "def", ";", "}", "return", "props", ".", "getProperty", "(", "propertyName", ",", "def", ")", ";", "}" ]

[ "Get", "a", "propety", "given", "to", "a", "particular", "tile", ".", "Note", "that", "this", "method", "will", "not", "perform", "well", "and", "should", "not", "be", "used", "as", "part", "of", "the", "default", "code", "path", "in", "the", "game", "loop", "." ]

[ "public", "void", "render", "(", "int", "x", ",", "int", "y", ",", "int", "layer", ")", "{", "render", "(", "x", ",", "y", ",", "0", ",", "0", ",", "getWidth", "(", ")", ",", "getHeight", "(", ")", ",", "layer", ",", "false", ")", ";", "}" ]

[ "Render", "a", "single", "layer", "from", "the", "map" ]

[ "protected", "void", "renderIsometricMap", "(", "int", "x", ",", "int", "y", ",", "int", "sx", ",", "int", "sy", ",", "int", "width", ",", "int", "height", ",", "Layer", "layer", ",", "boolean", "lineByLine", ")", "{", "ArrayList", "drawLayers", "=", "layers", ";", "if", "(", "layer", "!=", "null", ")", "{", "drawLayers", "=", "new", "ArrayList", "(", ")", ";", "drawLayers", ".", "add", "(", "layer", ")", ";", "}", "int", "maxCount", "=", "width", "*", "height", ";", "int", "allCount", "=", "0", ";", "boolean", "allProcessed", "=", "false", ";", "int", "initialLineX", "=", "x", ";", "int", "initialLineY", "=", "y", ";", "int", "startLineTileX", "=", "0", ";", "int", "startLineTileY", "=", "0", ";", "while", "(", "!", "allProcessed", ")", "{", "int", "currentTileX", "=", "startLineTileX", ";", "int", "currentTileY", "=", "startLineTileY", ";", "int", "currentLineX", "=", "initialLineX", ";", "int", "min", "=", "0", ";", "if", "(", "height", ">", "width", ")", "min", "=", "(", "startLineTileY", "<", "width", "-", "1", ")", "?", "startLineTileY", ":", "(", "width", "-", "currentTileX", "<", "height", ")", "?", "width", "-", "currentTileX", "-", "1", ":", "width", "-", "1", ";", "else", "min", "=", "(", "startLineTileY", "<", "height", "-", "1", ")", "?", "startLineTileY", ":", "(", "width", "-", "currentTileX", "<", "height", ")", "?", "width", "-", "currentTileX", "-", "1", ":", "height", "-", "1", ";", "for", "(", "int", "burner", "=", "0", ";", "burner", "<=", "min", ";", "currentTileX", "++", ",", "currentTileY", "--", ",", "burner", "++", ")", "{", "for", "(", "int", "layerIdx", "=", "0", ";", "layerIdx", "<", "drawLayers", ".", "size", "(", ")", ";", "layerIdx", "++", ")", "{", "Layer", "currentLayer", "=", "(", "Layer", ")", "drawLayers", ".", "get", "(", "layerIdx", ")", ";", "currentLayer", ".", "render", "(", "currentLineX", ",", "initialLineY", ",", "currentTileX", ",", "currentTileY", ",", "1", ",", "0", ",", "lineByLine", ",", "tileWidth", ",", "tileHeight", ")", ";", "}", "currentLineX", "+=", "tileWidth", ";", "allCount", "++", ";", "}", "// System.out.println(\"Line : \" + counter++ + \" - \" + count +\r", "// \"allcount : \" + allCount);\r", "if", "(", "startLineTileY", "<", "(", "height", "-", "1", ")", ")", "{", "startLineTileY", "+=", "1", ";", "initialLineX", "-=", "tileWidth", "/", "2", ";", "initialLineY", "+=", "tileHeight", "/", "2", ";", "}", "else", "{", "startLineTileX", "+=", "1", ";", "initialLineX", "+=", "tileWidth", "/", "2", ";", "initialLineY", "+=", "tileHeight", "/", "2", ";", "}", "if", "(", "allCount", ">=", "maxCount", ")", "allProcessed", "=", "true", ";", "}", "}" ]

[ "Render", "of", "isometric", "map", "renders", "." ]

[ "public", "TileSet", "getTileSetByGID", "(", "int", "gid", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "tileSets", ".", "size", "(", ")", ";", "i", "++", ")", "{", "TileSet", "set", "=", "(", "TileSet", ")", "tileSets", ".", "get", "(", "i", ")", ";", "if", "(", "set", ".", "contains", "(", "gid", ")", ")", "{", "return", "set", ";", "}", "}", "return", "null", ";", "}" ]

[ "Get", "a", "tileset", "by", "a", "given", "global", "ID" ]

[ "public", "int", "getObjectCount", "(", "int", "groupID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "return", "grp", ".", "objects", ".", "size", "(", ")", ";", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "number", "of", "objects", "of", "a", "specific", "object", "-", "group", "." ]

[ "public", "String", "getObjectName", "(", "int", "groupID", ",", "int", "objectID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "return", "object", ".", "name", ";", "}", "}", "return", "null", ";", "}" ]

[ "Return", "the", "name", "of", "a", "specific", "object", "from", "a", "specific", "group", "." ]

[ "public", "String", "getObjectType", "(", "int", "groupID", ",", "int", "objectID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "return", "object", ".", "type", ";", "}", "}", "return", "null", ";", "}" ]

[ "Return", "the", "type", "of", "an", "specific", "object", "from", "a", "specific", "group", "." ]

[ "public", "int", "getObjectX", "(", "int", "groupID", ",", "int", "objectID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "return", "object", ".", "x", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "x", "-", "coordinate", "of", "a", "specific", "object", "from", "a", "specific", "group", "." ]

[ "public", "int", "getObjectY", "(", "int", "groupID", ",", "int", "objectID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "return", "object", ".", "y", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "y", "-", "coordinate", "of", "a", "specific", "object", "from", "a", "specific", "group", "." ]

[ "public", "int", "getObjectWidth", "(", "int", "groupID", ",", "int", "objectID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "return", "object", ".", "width", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "width", "of", "a", "specific", "object", "from", "a", "specific", "group", "." ]

[ "public", "int", "getObjectHeight", "(", "int", "groupID", ",", "int", "objectID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "return", "object", ".", "height", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "height", "of", "a", "specific", "object", "from", "a", "specific", "group", "." ]

[ "public", "String", "getObjectImage", "(", "int", "groupID", ",", "int", "objectID", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "if", "(", "object", "==", "null", ")", "{", "return", "null", ";", "}", "return", "object", ".", "image", ";", "}", "}", "return", "null", ";", "}" ]

[ "Retrieve", "the", "image", "source", "property", "for", "a", "given", "object" ]

[ "public", "String", "getObjectProperty", "(", "int", "groupID", ",", "int", "objectID", ",", "String", "propertyName", ",", "String", "def", ")", "{", "if", "(", "groupID", ">=", "0", "&&", "groupID", "<", "objectGroups", ".", "size", "(", ")", ")", "{", "ObjectGroup", "grp", "=", "(", "ObjectGroup", ")", "objectGroups", ".", "get", "(", "groupID", ")", ";", "if", "(", "objectID", ">=", "0", "&&", "objectID", "<", "grp", ".", "objects", ".", "size", "(", ")", ")", "{", "GroupObject", "object", "=", "(", "GroupObject", ")", "grp", ".", "objects", ".", "get", "(", "objectID", ")", ";", "if", "(", "object", "==", "null", ")", "{", "return", "def", ";", "}", "if", "(", "object", ".", "props", "==", "null", ")", "{", "return", "def", ";", "}", "return", "object", ".", "props", ".", "getProperty", "(", "propertyName", ",", "def", ")", ";", "}", "}", "return", "def", ";", "}" ]

[ "Looks", "for", "a", "property", "with", "the", "given", "name", "and", "returns", "it", "s", "value", ".", "If", "no", "property", "is", "found", "def", "is", "returned", "." ]

[ "private", "static", "Element", "getFirstNamedElement", "(", "Element", "element", ",", "String", "name", ")", "{", "NodeList", "list", "=", "element", ".", "getElementsByTagName", "(", "name", ")", ";", "if", "(", "list", ".", "getLength", "(", ")", "==", "0", ")", "{", "return", "null", ";", "}", "return", "(", "Element", ")", "list", ".", "item", "(", "0", ")", ";", "}" ]

[ "Get", "the", "first", "child", "named", "as", "specified", "from", "the", "passed", "XML", "element" ]

[ "private", "static", "Element", "createRangeElement", "(", "Document", "document", ",", "String", "name", ",", "ConfigurableEmitter", ".", "Range", "range", ")", "{", "Element", "element", "=", "document", ".", "createElement", "(", "name", ")", ";", "element", ".", "setAttribute", "(", "\"min\"", ",", "\"\"", "+", "range", ".", "getMin", "(", ")", ")", ";", "element", ".", "setAttribute", "(", "\"max\"", ",", "\"\"", "+", "range", ".", "getMax", "(", ")", ")", ";", "element", ".", "setAttribute", "(", "\"enabled\"", ",", "\"\"", "+", "range", ".", "isEnabled", "(", ")", ")", ";", "return", "element", ";", "}" ]

[ "Create", "an", "XML", "element", "based", "on", "a", "configured", "range" ]

[ "private", "static", "Element", "createValueElement", "(", "Document", "document", ",", "String", "name", ",", "ConfigurableEmitter", ".", "Value", "value", ")", "{", "Element", "element", "=", "document", ".", "createElement", "(", "name", ")", ";", "// void: now writes the value type\r", "if", "(", "value", "instanceof", "SimpleValue", ")", "{", "element", ".", "setAttribute", "(", "\"type\"", ",", "\"simple\"", ")", ";", "element", ".", "setAttribute", "(", "\"value\"", ",", "\"\"", "+", "value", ".", "getValue", "(", "0", ")", ")", ";", "}", "else", "if", "(", "value", "instanceof", "RandomValue", ")", "{", "element", ".", "setAttribute", "(", "\"type\"", ",", "\"random\"", ")", ";", "element", ".", "setAttribute", "(", "\"value\"", ",", "\"\"", "+", "(", "(", "RandomValue", ")", "value", ")", ".", "getValue", "(", ")", ")", ";", "}", "else", "if", "(", "value", "instanceof", "LinearInterpolator", ")", "{", "element", ".", "setAttribute", "(", "\"type\"", ",", "\"linear\"", ")", ";", "element", ".", "setAttribute", "(", "\"min\"", ",", "\"\"", "+", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "getMin", "(", ")", ")", ";", "element", ".", "setAttribute", "(", "\"max\"", ",", "\"\"", "+", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "getMax", "(", ")", ")", ";", "element", ".", "setAttribute", "(", "\"active\"", ",", "\"\"", "+", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "isActive", "(", ")", ")", ";", "ArrayList", "curve", "=", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "getCurve", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "curve", ".", "size", "(", ")", ";", "i", "++", ")", "{", "Vector2f", "point", "=", "(", "Vector2f", ")", "curve", ".", "get", "(", "i", ")", ";", "Element", "pointElement", "=", "document", ".", "createElement", "(", "\"point\"", ")", ";", "pointElement", ".", "setAttribute", "(", "\"x\"", ",", "\"\"", "+", "point", ".", "x", ")", ";", "pointElement", ".", "setAttribute", "(", "\"y\"", ",", "\"\"", "+", "point", ".", "y", ")", ";", "element", ".", "appendChild", "(", "pointElement", ")", ";", "}", "}", "else", "{", "Log", ".", "warn", "(", "\"unkown value type ignored: \"", "+", "value", ".", "getClass", "(", ")", ")", ";", "}", "return", "element", ";", "}" ]

[ "Create", "an", "XML", "element", "based", "on", "a", "configured", "value" ]

[ "private", "static", "void", "parseRangeElement", "(", "Element", "element", ",", "ConfigurableEmitter", ".", "Range", "range", ")", "{", "if", "(", "element", "==", "null", ")", "{", "return", ";", "}", "range", ".", "setMin", "(", "Float", ".", "parseFloat", "(", "element", ".", "getAttribute", "(", "\"min\"", ")", ")", ")", ";", "range", ".", "setMax", "(", "Float", ".", "parseFloat", "(", "element", ".", "getAttribute", "(", "\"max\"", ")", ")", ")", ";", "range", ".", "setEnabled", "(", "\"true\"", ".", "equals", "(", "element", ".", "getAttribute", "(", "\"enabled\"", ")", ")", ")", ";", "}" ]

[ "Parse", "an", "XML", "element", "into", "a", "configured", "range" ]

[ "private", "static", "void", "parseValueElement", "(", "Element", "element", ",", "ConfigurableEmitter", ".", "Value", "value", ")", "{", "if", "(", "element", "==", "null", ")", "{", "return", ";", "}", "String", "type", "=", "element", ".", "getAttribute", "(", "\"type\"", ")", ";", "String", "v", "=", "element", ".", "getAttribute", "(", "\"value\"", ")", ";", "if", "(", "type", "==", "null", "||", "type", ".", "length", "(", ")", "==", "0", ")", "{", "// support for old style which did not write the type\r", "if", "(", "value", "instanceof", "SimpleValue", ")", "{", "(", "(", "SimpleValue", ")", "value", ")", ".", "setValue", "(", "Float", ".", "parseFloat", "(", "v", ")", ")", ";", "}", "else", "if", "(", "value", "instanceof", "RandomValue", ")", "{", "(", "(", "RandomValue", ")", "value", ")", ".", "setValue", "(", "Float", ".", "parseFloat", "(", "v", ")", ")", ";", "}", "else", "{", "Log", ".", "warn", "(", "\"problems reading element, skipping: \"", "+", "element", ")", ";", "}", "}", "else", "{", "// type given: this is the new style\r", "if", "(", "type", ".", "equals", "(", "\"simple\"", ")", ")", "{", "(", "(", "SimpleValue", ")", "value", ")", ".", "setValue", "(", "Float", ".", "parseFloat", "(", "v", ")", ")", ";", "}", "else", "if", "(", "type", ".", "equals", "(", "\"random\"", ")", ")", "{", "(", "(", "RandomValue", ")", "value", ")", ".", "setValue", "(", "Float", ".", "parseFloat", "(", "v", ")", ")", ";", "}", "else", "if", "(", "type", ".", "equals", "(", "\"linear\"", ")", ")", "{", "String", "min", "=", "element", ".", "getAttribute", "(", "\"min\"", ")", ";", "String", "max", "=", "element", ".", "getAttribute", "(", "\"max\"", ")", ";", "String", "active", "=", "element", ".", "getAttribute", "(", "\"active\"", ")", ";", "NodeList", "points", "=", "element", ".", "getElementsByTagName", "(", "\"point\"", ")", ";", "ArrayList", "curve", "=", "new", "ArrayList", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "points", ".", "getLength", "(", ")", ";", "i", "++", ")", "{", "Element", "point", "=", "(", "Element", ")", "points", ".", "item", "(", "i", ")", ";", "float", "x", "=", "Float", ".", "parseFloat", "(", "point", ".", "getAttribute", "(", "\"x\"", ")", ")", ";", "float", "y", "=", "Float", ".", "parseFloat", "(", "point", ".", "getAttribute", "(", "\"y\"", ")", ")", ";", "curve", ".", "add", "(", "new", "Vector2f", "(", "x", ",", "y", ")", ")", ";", "}", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "setCurve", "(", "curve", ")", ";", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "setMin", "(", "Integer", ".", "parseInt", "(", "min", ")", ")", ";", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "setMax", "(", "Integer", ".", "parseInt", "(", "max", ")", ")", ";", "(", "(", "LinearInterpolator", ")", "value", ")", ".", "setActive", "(", "\"true\"", ".", "equals", "(", "active", ")", ")", ";", "}", "else", "{", "Log", ".", "warn", "(", "\"unkown type detected: \"", "+", "type", ")", ";", "}", "}", "}" ]

[ "Parse", "an", "XML", "element", "into", "a", "configured", "value" ]

[ "public", "NavMesh", "build", "(", "TileBasedMap", "map", ",", "boolean", "tileBased", ")", "{", "this", ".", "tileBased", "=", "tileBased", ";", "ArrayList", "spaces", "=", "new", "ArrayList", "(", ")", ";", "if", "(", "tileBased", ")", "{", "for", "(", "int", "x", "=", "0", ";", "x", "<", "map", ".", "getWidthInTiles", "(", ")", ";", "x", "++", ")", "{", "for", "(", "int", "y", "=", "0", ";", "y", "<", "map", ".", "getHeightInTiles", "(", ")", ";", "y", "++", ")", "{", "if", "(", "!", "map", ".", "blocked", "(", "this", ",", "x", ",", "y", ")", ")", "{", "spaces", ".", "add", "(", "new", "Space", "(", "x", ",", "y", ",", "1", ",", "1", ")", ")", ";", "}", "}", "}", "}", "else", "{", "Space", "space", "=", "new", "Space", "(", "0", ",", "0", ",", "map", ".", "getWidthInTiles", "(", ")", ",", "map", ".", "getHeightInTiles", "(", ")", ")", ";", "subsection", "(", "map", ",", "space", ",", "spaces", ")", ";", "}", "while", "(", "mergeSpaces", "(", "spaces", ")", ")", "{", "}", "linkSpaces", "(", "spaces", ")", ";", "return", "new", "NavMesh", "(", "spaces", ")", ";", "}" ]

[ "Build", "a", "navigation", "mesh", "based", "on", "a", "tile", "map" ]

[ "private", "boolean", "mergeSpaces", "(", "ArrayList", "spaces", ")", "{", "for", "(", "int", "source", "=", "0", ";", "source", "<", "spaces", ".", "size", "(", ")", ";", "source", "++", ")", "{", "Space", "a", "=", "(", "Space", ")", "spaces", ".", "get", "(", "source", ")", ";", "for", "(", "int", "target", "=", "source", "+", "1", ";", "target", "<", "spaces", ".", "size", "(", ")", ";", "target", "++", ")", "{", "Space", "b", "=", "(", "Space", ")", "spaces", ".", "get", "(", "target", ")", ";", "if", "(", "a", ".", "canMerge", "(", "b", ")", ")", "{", "spaces", ".", "remove", "(", "a", ")", ";", "spaces", ".", "remove", "(", "b", ")", ";", "spaces", ".", "add", "(", "a", ".", "merge", "(", "b", ")", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Merge", "the", "spaces", "that", "have", "been", "created", "to", "optimize", "out", "anywhere", "we", "can", "." ]

[ "private", "void", "linkSpaces", "(", "ArrayList", "spaces", ")", "{", "for", "(", "int", "source", "=", "0", ";", "source", "<", "spaces", ".", "size", "(", ")", ";", "source", "++", ")", "{", "Space", "a", "=", "(", "Space", ")", "spaces", ".", "get", "(", "source", ")", ";", "for", "(", "int", "target", "=", "source", "+", "1", ";", "target", "<", "spaces", ".", "size", "(", ")", ";", "target", "++", ")", "{", "Space", "b", "=", "(", "Space", ")", "spaces", ".", "get", "(", "target", ")", ";", "if", "(", "a", ".", "hasJoinedEdge", "(", "b", ")", ")", "{", "a", ".", "link", "(", "b", ")", ";", "b", ".", "link", "(", "a", ")", ";", "}", "}", "}", "}" ]

[ "Determine", "the", "links", "between", "spaces" ]

[ "public", "boolean", "clear", "(", "TileBasedMap", "map", ",", "Space", "space", ")", "{", "if", "(", "tileBased", ")", "{", "return", "true", ";", "}", "float", "x", "=", "0", ";", "boolean", "donex", "=", "false", ";", "while", "(", "x", "<", "space", ".", "getWidth", "(", ")", ")", "{", "float", "y", "=", "0", ";", "boolean", "doney", "=", "false", ";", "while", "(", "y", "<", "space", ".", "getHeight", "(", ")", ")", "{", "sx", "=", "(", "int", ")", "(", "space", ".", "getX", "(", ")", "+", "x", ")", ";", "sy", "=", "(", "int", ")", "(", "space", ".", "getY", "(", ")", "+", "y", ")", ";", "if", "(", "map", ".", "blocked", "(", "this", ",", "sx", ",", "sy", ")", ")", "{", "return", "false", ";", "}", "y", "+=", "0.1f", ";", "if", "(", "(", "y", ">", "space", ".", "getHeight", "(", ")", ")", "&&", "(", "!", "doney", ")", ")", "{", "y", "=", "space", ".", "getHeight", "(", ")", ";", "doney", "=", "true", ";", "}", "}", "x", "+=", "0.1f", ";", "if", "(", "(", "x", ">", "space", ".", "getWidth", "(", ")", ")", "&&", "(", "!", "donex", ")", ")", "{", "x", "=", "space", ".", "getWidth", "(", ")", ";", "donex", "=", "true", ";", "}", "}", "return", "true", ";", "}" ]

[ "Check", "if", "a", "particular", "space", "is", "clear", "of", "blockages" ]

[ "private", "void", "subsection", "(", "TileBasedMap", "map", ",", "Space", "space", ",", "ArrayList", "spaces", ")", "{", "if", "(", "!", "clear", "(", "map", ",", "space", ")", ")", "{", "float", "width2", "=", "space", ".", "getWidth", "(", ")", "/", "2", ";", "float", "height2", "=", "space", ".", "getHeight", "(", ")", "/", "2", ";", "if", "(", "(", "width2", "<", "smallestSpace", ")", "&&", "(", "height2", "<", "smallestSpace", ")", ")", "{", "return", ";", "}", "subsection", "(", "map", ",", "new", "Space", "(", "space", ".", "getX", "(", ")", ",", "space", ".", "getY", "(", ")", ",", "width2", ",", "height2", ")", ",", "spaces", ")", ";", "subsection", "(", "map", ",", "new", "Space", "(", "space", ".", "getX", "(", ")", ",", "space", ".", "getY", "(", ")", "+", "height2", ",", "width2", ",", "height2", ")", ",", "spaces", ")", ";", "subsection", "(", "map", ",", "new", "Space", "(", "space", ".", "getX", "(", ")", "+", "width2", ",", "space", ".", "getY", "(", ")", ",", "width2", ",", "height2", ")", ",", "spaces", ")", ";", "subsection", "(", "map", ",", "new", "Space", "(", "space", ".", "getX", "(", ")", "+", "width2", ",", "space", ".", "getY", "(", ")", "+", "height2", ",", "width2", ",", "height2", ")", ",", "spaces", ")", ";", "}", "else", "{", "spaces", ".", "add", "(", "space", ")", ";", "}", "}" ]

[ "Subsection", "a", "space", "into", "smaller", "spaces", "if", "required", "to", "find", "a", "non", "-", "blocked", "area", "." ]

[ "public", "void", "setPosition", "(", "int", "x", ",", "int", "y", ")", "{", "int", "cx", "=", "(", "xoffset", ".", "getMin", "(", ")", "+", "xoffset", ".", "getMax", "(", ")", ")", "/", "2", ";", "int", "cy", "=", "(", "yoffset", ".", "getMin", "(", ")", "+", "yoffset", ".", "getMax", "(", ")", ")", "/", "2", ";", "int", "dx", "=", "x", "-", "cx", ";", "int", "dy", "=", "y", "-", "cy", ";", "xoffset", ".", "setMin", "(", "xoffset", ".", "getMin", "(", ")", "+", "dx", ")", ";", "xoffset", ".", "setMax", "(", "xoffset", ".", "getMax", "(", ")", "+", "dx", ")", ";", "yoffset", ".", "setMin", "(", "yoffset", ".", "getMin", "(", ")", "+", "dy", ")", ";", "yoffset", ".", "setMax", "(", "yoffset", ".", "getMax", "(", ")", "+", "dy", ")", ";", "xoffset", ".", "fireUpdated", "(", "null", ")", ";", "yoffset", ".", "fireUpdated", "(", "null", ")", ";", "}" ]

[ "Set", "the", "position", "of", "the", "emitter" ]

[ "public", "void", "start", "(", ")", "throws", "SlickException", "{", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "public", "void", "run", "(", ")", "{", "try", "{", "Input", ".", "disableControllers", "(", ")", ";", "try", "{", "Display", ".", "setParent", "(", "CanvasGameContainer", ".", "this", ")", ";", "}", "catch", "(", "LWJGLException", "e", ")", "{", "throw", "new", "SlickException", "(", "\"Failed to setParent of canvas\"", ",", "e", ")", ";", "}", "container", ".", "setup", "(", ")", ";", "scheduleUpdate", "(", ")", ";", "}", "catch", "(", "SlickException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "System", ".", "exit", "(", "0", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "Start", "the", "game", "container", "rendering" ]

[ "private", "void", "scheduleUpdate", "(", ")", "{", "if", "(", "!", "isVisible", "(", ")", ")", "{", "return", ";", "}", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "public", "void", "run", "(", ")", "{", "try", "{", "container", ".", "gameLoop", "(", ")", ";", "}", "catch", "(", "SlickException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "container", ".", "checkDimensions", "(", ")", ";", "scheduleUpdate", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Schedule", "an", "update", "on", "the", "EDT" ]

[ "public", "float", "distance2", "(", "float", "tx", ",", "float", "ty", ")", "{", "float", "dx", "=", "tx", "-", "px", ";", "float", "dy", "=", "ty", "-", "py", ";", "return", "(", "(", "dx", "*", "dx", ")", "+", "(", "dy", "*", "dy", ")", ")", ";", "}" ]

[ "Get", "the", "distance", "squared", "from", "this", "link", "to", "the", "given", "position" ]

[ "public", "void", "renderLines", "(", "float", "[", "]", "points", ",", "int", "count", ")", "{", "if", "(", "antialias", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_POLYGON_SMOOTH", ")", ";", "renderLinesImpl", "(", "points", ",", "count", ",", "width", "+", "1f", ")", ";", "}", "GL", ".", "glDisable", "(", "SGL", ".", "GL_POLYGON_SMOOTH", ")", ";", "renderLinesImpl", "(", "points", ",", "count", ",", "width", ")", ";", "if", "(", "antialias", ")", "{", "GL", ".", "glEnable", "(", "SGL", ".", "GL_POLYGON_SMOOTH", ")", ";", "}", "}" ]

[ "Render", "the", "lines", "applying", "antialiasing", "if", "required" ]

[ "private", "void", "bindColor", "(", "int", "index", ")", "{", "if", "(", "index", "<", "cpt", ")", "{", "if", "(", "renderHalf", ")", "{", "GL", ".", "glColor4f", "(", "colours", "[", "(", "index", "*", "4", ")", "]", "*", "0.5f", ",", "colours", "[", "(", "index", "*", "4", ")", "+", "1", "]", "*", "0.5f", ",", "colours", "[", "(", "index", "*", "4", ")", "+", "2", "]", "*", "0.5f", ",", "colours", "[", "(", "index", "*", "4", ")", "+", "3", "]", "*", "0.5f", ")", ";", "}", "else", "{", "GL", ".", "glColor4f", "(", "colours", "[", "(", "index", "*", "4", ")", "]", ",", "colours", "[", "(", "index", "*", "4", ")", "+", "1", "]", ",", "colours", "[", "(", "index", "*", "4", ")", "+", "2", "]", ",", "colours", "[", "(", "index", "*", "4", ")", "+", "3", "]", ")", ";", "}", "}", "}" ]

[ "Bind", "the", "colour", "at", "a", "given", "index", "in", "the", "array" ]

[ "public", "static", "void", "enterSafeBlock", "(", ")", "{", "if", "(", "inSafe", ")", "{", "return", ";", "}", "Renderer", ".", "get", "(", ")", ".", "flush", "(", ")", ";", "lastUsed", "=", "TextureImpl", ".", "getLastBind", "(", ")", ";", "TextureImpl", ".", "bindNone", "(", ")", ";", "GL11", ".", "glPushAttrib", "(", "GL11", ".", "GL_ALL_ATTRIB_BITS", ")", ";", "GL11", ".", "glPushClientAttrib", "(", "GL11", ".", "GL_ALL_CLIENT_ATTRIB_BITS", ")", ";", "GL11", ".", "glMatrixMode", "(", "GL11", ".", "GL_MODELVIEW", ")", ";", "GL11", ".", "glPushMatrix", "(", ")", ";", "GL11", ".", "glMatrixMode", "(", "GL11", ".", "GL_PROJECTION", ")", ";", "GL11", ".", "glPushMatrix", "(", ")", ";", "GL11", ".", "glMatrixMode", "(", "GL11", ".", "GL_MODELVIEW", ")", ";", "inSafe", "=", "true", ";", "}" ]

[ "Enter", "a", "safe", "block", "ensuring", "that", "all", "the", "OpenGL", "state", "that", "slick", "uses", "is", "safe", "before", "touching", "the", "GL", "state", "directly", "." ]

[ "public", "static", "void", "leaveSafeBlock", "(", ")", "{", "if", "(", "!", "inSafe", ")", "{", "return", ";", "}", "GL11", ".", "glMatrixMode", "(", "GL11", ".", "GL_PROJECTION", ")", ";", "GL11", ".", "glPopMatrix", "(", ")", ";", "GL11", ".", "glMatrixMode", "(", "GL11", ".", "GL_MODELVIEW", ")", ";", "GL11", ".", "glPopMatrix", "(", ")", ";", "GL11", ".", "glPopClientAttrib", "(", ")", ";", "GL11", ".", "glPopAttrib", "(", ")", ";", "if", "(", "lastUsed", "!=", "null", ")", "{", "lastUsed", ".", "bind", "(", ")", ";", "}", "else", "{", "TextureImpl", ".", "bindNone", "(", ")", ";", "}", "inSafe", "=", "false", ";", "}" ]

[ "Leave", "a", "safe", "block", "ensuring", "that", "all", "of", "Slick", "s", "OpenGL", "state", "is", "restored", "since", "the", "last", "enter", "." ]

[ "private", "List", "createPoints", "(", "int", "numberOfSegments", ",", "float", "radius", ",", "float", "cx", ",", "float", "cy", ",", "float", "start", ",", "float", "end", ")", "{", "ArrayList", "tempPoints", "=", "new", "ArrayList", "(", ")", ";", "int", "step", "=", "360", "/", "numberOfSegments", ";", "for", "(", "float", "a", "=", "start", ";", "a", "<=", "end", "+", "step", ";", "a", "+=", "step", ")", "{", "float", "ang", "=", "a", ";", "if", "(", "ang", ">", "end", ")", "{", "ang", "=", "end", ";", "}", "float", "x", "=", "(", "float", ")", "(", "cx", "+", "(", "FastTrig", ".", "cos", "(", "Math", ".", "toRadians", "(", "ang", ")", ")", "*", "radius", ")", ")", ";", "float", "y", "=", "(", "float", ")", "(", "cy", "+", "(", "FastTrig", ".", "sin", "(", "Math", ".", "toRadians", "(", "ang", ")", ")", "*", "radius", ")", ")", ";", "tempPoints", ".", "add", "(", "new", "Float", "(", "x", ")", ")", ";", "tempPoints", ".", "add", "(", "new", "Float", "(", "y", ")", ")", ";", "}", "return", "tempPoints", ";", "}" ]

[ "Generate", "the", "points", "to", "fill", "a", "corner", "arc", "." ]

[ "private", "void", "fireUpdated", "(", "Object", "source", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "listeners", ".", "size", "(", ")", ";", "i", "++", ")", "{", "(", "(", "InputPanelListener", ")", "listeners", ".", "get", "(", "i", ")", ")", ".", "valueUpdated", "(", "this", ")", ";", "}", "}" ]

[ "Fire", "notification", "of", "updates", "to", "all", "listeners" ]

[ "private", "void", "loadBackground", "(", ")", "{", "JFileChooser", "chooser", "=", "new", "JFileChooser", "(", "\".\"", ")", ";", "chooser", ".", "setDialogTitle", "(", "\"Open\"", ")", ";", "int", "resp", "=", "chooser", ".", "showOpenDialog", "(", "this", ")", ";", "if", "(", "resp", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "game", ".", "setBackgroundImage", "(", "chooser", ".", "getSelectedFile", "(", ")", ")", ";", "}", "}" ]

[ "Load", "a", "background", "image", "to", "display", "behind", "the", "particle", "system" ]

[ "private", "void", "initGraphEditorWindow", "(", ")", "{", "// create the window\r", "GraphEditorWindow", "editor", "=", "new", "GraphEditorWindow", "(", ")", ";", "whiskasPanel", ".", "setEditor", "(", "editor", ")", ";", "graphEditorFrame", "=", "new", "JFrame", "(", "\"Whiskas Gradient Editor\"", ")", ";", "graphEditorFrame", ".", "getContentPane", "(", ")", ".", "add", "(", "editor", ")", ";", "graphEditorFrame", ".", "setDefaultCloseOperation", "(", "WindowConstants", ".", "HIDE_ON_CLOSE", ")", ";", "graphEditorFrame", ".", "pack", "(", ")", ";", "graphEditorFrame", ".", "setSize", "(", "600", ",", "300", ")", ";", "graphEditorFrame", ".", "setLocation", "(", "this", ".", "getX", "(", ")", ",", "this", ".", "getY", "(", ")", "+", "this", ".", "getHeight", "(", ")", ")", ";", "graphEditorFrame", ".", "setVisible", "(", "true", ")", ";", "//\t\ttry {\r", "//\t\t\tInputStream in = ParticleEditor.class.getClassLoader().getResourceAsStream(\"org/newdawn/slick/tools/peditor/data/icon.gif\");\r", "//\t\t\t\r", "//\t\t\t//graphEditorFrame.setIconImage(ImageIO.read(in));\r", "//\t\t} catch (IOException e) {\r", "//\t\t\te.printStackTrace();\r", "//\t\t}\r", "}" ]

[ "init", "the", "graph", "editor", "window" ]

[ "public", "void", "importEmitter", "(", ")", "{", "chooser", ".", "setDialogTitle", "(", "\"Open\"", ")", ";", "int", "resp", "=", "chooser", ".", "showOpenDialog", "(", "this", ")", ";", "if", "(", "resp", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "File", "file", "=", "chooser", ".", "getSelectedFile", "(", ")", ";", "File", "path", "=", "file", ".", "getParentFile", "(", ")", ";", "try", "{", "final", "ConfigurableEmitter", "emitter", "=", "ParticleIO", ".", "loadEmitter", "(", "file", ")", ";", "if", "(", "emitter", ".", "getImageName", "(", ")", "!=", "null", ")", "{", "File", "possible", "=", "new", "File", "(", "path", ",", "emitter", ".", "getImageName", "(", ")", ")", ";", "if", "(", "possible", ".", "exists", "(", ")", ")", "{", "emitter", ".", "setImageName", "(", "possible", ".", "getAbsolutePath", "(", ")", ")", ";", "}", "else", "{", "chooser", ".", "setDialogTitle", "(", "\"Locate the image: \"", "+", "emitter", ".", "getImageName", "(", ")", ")", ";", "resp", "=", "chooser", ".", "showOpenDialog", "(", "this", ")", ";", "FileFilter", "filter", "=", "new", "FileFilter", "(", ")", "{", "public", "boolean", "accept", "(", "File", "f", ")", "{", "if", "(", "f", ".", "isDirectory", "(", ")", ")", "{", "return", "true", ";", "}", "return", "(", "f", ".", "getName", "(", ")", ".", "equals", "(", "emitter", ".", "getImageName", "(", ")", ")", ")", ";", "}", "public", "String", "getDescription", "(", ")", "{", "return", "emitter", ".", "getImageName", "(", ")", ";", "}", "}", ";", "chooser", ".", "addChoosableFileFilter", "(", "filter", ")", ";", "if", "(", "resp", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "File", "image", "=", "chooser", ".", "getSelectedFile", "(", ")", ";", "emitter", ".", "setImageName", "(", "image", ".", "getAbsolutePath", "(", ")", ")", ";", "path", "=", "image", ".", "getParentFile", "(", ")", ";", "}", "chooser", ".", "resetChoosableFileFilters", "(", ")", ";", "chooser", ".", "addChoosableFileFilter", "(", "xmlFileFilter", ")", ";", "}", "}", "addEmitter", "(", "emitter", ")", ";", "emitters", ".", "setSelected", "(", "emitter", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "JOptionPane", ".", "showMessageDialog", "(", "this", ",", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}", "}" ]

[ "Import", "an", "emitter", "XML", "file" ]

[ "public", "void", "cloneEmitter", "(", ")", "{", "if", "(", "selected", "==", "null", ")", "{", "return", ";", "}", "try", "{", "ByteArrayOutputStream", "bout", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "ParticleIO", ".", "saveEmitter", "(", "bout", ",", "selected", ")", ";", "ByteArrayInputStream", "bin", "=", "new", "ByteArrayInputStream", "(", "bout", ".", "toByteArray", "(", ")", ")", ";", "ConfigurableEmitter", "emitter", "=", "ParticleIO", ".", "loadEmitter", "(", "bin", ")", ";", "emitter", ".", "name", "=", "emitter", ".", "name", "+", "\"_clone\"", ";", "addEmitter", "(", "emitter", ")", ";", "emitters", ".", "setSelected", "(", "emitter", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "JOptionPane", ".", "showMessageDialog", "(", "this", ",", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}" ]

[ "Clone", "the", "selected", "emitter" ]

[ "public", "void", "exportEmitter", "(", ")", "{", "if", "(", "selected", "==", "null", ")", "{", "return", ";", "}", "chooser", ".", "setDialogTitle", "(", "\"Save\"", ")", ";", "int", "resp", "=", "chooser", ".", "showSaveDialog", "(", "this", ")", ";", "if", "(", "resp", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "File", "file", "=", "chooser", ".", "getSelectedFile", "(", ")", ";", "if", "(", "!", "file", ".", "getName", "(", ")", ".", "endsWith", "(", "\".xml\"", ")", ")", "{", "file", "=", "new", "File", "(", "file", ".", "getAbsolutePath", "(", ")", "+", "\".xml\"", ")", ";", "}", "try", "{", "ParticleIO", ".", "saveEmitter", "(", "file", ",", "selected", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "JOptionPane", ".", "showMessageDialog", "(", "this", ",", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}", "}" ]

[ "Export", "an", "emitter", "XML", "file" ]

[ "public", "void", "createNewSystem", "(", ")", "{", "game", ".", "clearSystem", "(", "additive", ".", "isSelected", "(", ")", ")", ";", "pointsEnabled", ".", "setSelected", "(", "false", ")", ";", "emitters", ".", "clear", "(", ")", ";", "}" ]

[ "Create", "a", "completely", "new", "particle", "system" ]

[ "public", "void", "loadSystem", "(", ")", "{", "chooser", ".", "setDialogTitle", "(", "\"Open\"", ")", ";", "int", "resp", "=", "chooser", ".", "showOpenDialog", "(", "this", ")", ";", "if", "(", "resp", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "File", "file", "=", "chooser", ".", "getSelectedFile", "(", ")", ";", "File", "path", "=", "file", ".", "getParentFile", "(", ")", ";", "try", "{", "ParticleSystem", "system", "=", "ParticleIO", ".", "loadConfiguredSystem", "(", "file", ")", ";", "game", ".", "setSystem", "(", "system", ")", ";", "emitters", ".", "clear", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "system", ".", "getEmitterCount", "(", ")", ";", "i", "++", ")", "{", "final", "ConfigurableEmitter", "emitter", "=", "(", "ConfigurableEmitter", ")", "system", ".", "getEmitter", "(", "i", ")", ";", "if", "(", "emitter", ".", "getImageName", "(", ")", "!=", "null", ")", "{", "File", "possible", "=", "new", "File", "(", "path", ",", "emitter", ".", "getImageName", "(", ")", ")", ";", "if", "(", "possible", ".", "exists", "(", ")", ")", "{", "emitter", ".", "setImageName", "(", "possible", ".", "getAbsolutePath", "(", ")", ")", ";", "}", "else", "{", "chooser", ".", "setDialogTitle", "(", "\"Locate the image: \"", "+", "emitter", ".", "getImageName", "(", ")", ")", ";", "FileFilter", "filter", "=", "new", "FileFilter", "(", ")", "{", "public", "boolean", "accept", "(", "File", "f", ")", "{", "if", "(", "f", ".", "isDirectory", "(", ")", ")", "{", "return", "true", ";", "}", "return", "(", "f", ".", "getName", "(", ")", ".", "equals", "(", "emitter", ".", "getImageName", "(", ")", ")", ")", ";", "}", "public", "String", "getDescription", "(", ")", "{", "return", "emitter", ".", "getImageName", "(", ")", ";", "}", "}", ";", "chooser", ".", "addChoosableFileFilter", "(", "filter", ")", ";", "resp", "=", "chooser", ".", "showOpenDialog", "(", "this", ")", ";", "if", "(", "resp", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "File", "image", "=", "chooser", ".", "getSelectedFile", "(", ")", ";", "emitter", ".", "setImageName", "(", "image", ".", "getAbsolutePath", "(", ")", ")", ";", "path", "=", "image", ".", "getParentFile", "(", ")", ";", "}", "chooser", ".", "setDialogTitle", "(", "\"Open\"", ")", ";", "chooser", ".", "resetChoosableFileFilters", "(", ")", ";", "chooser", ".", "addChoosableFileFilter", "(", "xmlFileFilter", ")", ";", "}", "}", "emitters", ".", "add", "(", "emitter", ")", ";", "}", "additive", ".", "setSelected", "(", "system", ".", "getBlendingMode", "(", ")", "==", "ParticleSystem", ".", "BLEND_ADDITIVE", ")", ";", "pointsEnabled", ".", "setSelected", "(", "system", ".", "usePoints", "(", ")", ")", ";", "emitters", ".", "setSelected", "(", "0", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "JOptionPane", ".", "showMessageDialog", "(", "this", ",", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}", "}" ]

[ "Load", "a", "complete", "particle", "system", "XML", "description" ]

[ "public", "void", "saveSystem", "(", ")", "{", "int", "resp", "=", "chooser", ".", "showSaveDialog", "(", "this", ")", ";", "if", "(", "resp", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "File", "file", "=", "chooser", ".", "getSelectedFile", "(", ")", ";", "if", "(", "!", "file", ".", "getName", "(", ")", ".", "endsWith", "(", "\".xml\"", ")", ")", "{", "file", "=", "new", "File", "(", "file", ".", "getAbsolutePath", "(", ")", "+", "\".xml\"", ")", ";", "}", "try", "{", "ParticleIO", ".", "saveConfiguredSystem", "(", "file", ",", "game", ".", "getSystem", "(", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "JOptionPane", ".", "showMessageDialog", "(", "this", ",", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}", "}" ]

[ "Save", "a", "complete", "particle", "system", "XML", "description" ]

[ "public", "void", "setCurrentEmitter", "(", "ConfigurableEmitter", "emitter", ")", "{", "this", ".", "selected", "=", "emitter", ";", "if", "(", "emitter", "==", "null", ")", "{", "emissionControls", ".", "setEnabled", "(", "false", ")", ";", "settingsPanel", ".", "setEnabled", "(", "false", ")", ";", "positionControls", ".", "setEnabled", "(", "false", ")", ";", "colorPanel", ".", "setEnabled", "(", "false", ")", ";", "limitPanel", ".", "setEnabled", "(", "false", ")", ";", "whiskasPanel", ".", "setEnabled", "(", "false", ")", ";", "}", "else", "{", "emissionControls", ".", "setEnabled", "(", "true", ")", ";", "settingsPanel", ".", "setEnabled", "(", "true", ")", ";", "positionControls", ".", "setEnabled", "(", "true", ")", ";", "colorPanel", ".", "setEnabled", "(", "true", ")", ";", "limitPanel", ".", "setEnabled", "(", "true", ")", ";", "whiskasPanel", ".", "setEnabled", "(", "true", ")", ";", "emissionControls", ".", "setTarget", "(", "emitter", ")", ";", "settingsPanel", ".", "setTarget", "(", "emitter", ")", ";", "positionControls", ".", "setTarget", "(", "emitter", ")", ";", "settingsPanel", ".", "setTarget", "(", "emitter", ")", ";", "colorPanel", ".", "setTarget", "(", "emitter", ")", ";", "limitPanel", ".", "setTarget", "(", "emitter", ")", ";", "whiskasPanel", ".", "setTarget", "(", "emitter", ")", ";", "}", "}" ]

[ "Set", "the", "currently", "selected", "and", "edited", "particle", "emitter" ]

[ "public", "void", "updateBlendMode", "(", ")", "{", "if", "(", "additive", ".", "isSelected", "(", ")", ")", "{", "game", ".", "getSystem", "(", ")", ".", "setBlendingMode", "(", "ParticleSystem", ".", "BLEND_ADDITIVE", ")", ";", "}", "else", "{", "game", ".", "getSystem", "(", ")", ".", "setBlendingMode", "(", "ParticleSystem", ".", "BLEND_COMBINE", ")", ";", "}", "}" ]

[ "Change", "the", "visual", "indicator", "for", "the", "current", "particle", "system", "blend", "mode" ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "argv", ")", "{", "try", "{", "UIManager", ".", "setLookAndFeel", "(", "UIManager", ".", "getSystemLookAndFeelClassName", "(", ")", ")", ";", "new", "ParticleEditor", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "Log", ".", "error", "(", "e", ")", ";", "}", "}" ]

[ "Entry", "point", "in", "the", "editor" ]

[ "public", "static", "InputStream", "getResourceAsStream", "(", "String", "ref", ")", "{", "InputStream", "in", "=", "null", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "locations", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ResourceLocation", "location", "=", "(", "ResourceLocation", ")", "locations", ".", "get", "(", "i", ")", ";", "in", "=", "location", ".", "getResourceAsStream", "(", "ref", ")", ";", "if", "(", "in", "!=", "null", ")", "{", "break", ";", "}", "}", "if", "(", "in", "==", "null", ")", "{", "throw", "new", "RuntimeException", "(", "\"Resource not found: \"", "+", "ref", ")", ";", "}", "return", "new", "BufferedInputStream", "(", "in", ")", ";", "}" ]

[ "Get", "a", "resource" ]

[ "public", "static", "boolean", "resourceExists", "(", "String", "ref", ")", "{", "URL", "url", "=", "null", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "locations", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ResourceLocation", "location", "=", "(", "ResourceLocation", ")", "locations", ".", "get", "(", "i", ")", ";", "url", "=", "location", ".", "getResource", "(", "ref", ")", ";", "if", "(", "url", "!=", "null", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "if", "a", "resource", "is", "available", "from", "any", "given", "resource", "loader" ]

[ "public", "static", "URL", "getResource", "(", "String", "ref", ")", "{", "URL", "url", "=", "null", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "locations", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ResourceLocation", "location", "=", "(", "ResourceLocation", ")", "locations", ".", "get", "(", "i", ")", ";", "url", "=", "location", ".", "getResource", "(", "ref", ")", ";", "if", "(", "url", "!=", "null", ")", "{", "break", ";", "}", "}", "if", "(", "url", "==", "null", ")", "{", "throw", "new", "RuntimeException", "(", "\"Resource not found: \"", "+", "ref", ")", ";", "}", "return", "url", ";", "}" ]

[ "Get", "a", "resource", "as", "a", "URL" ]

[ "public", "void", "setPosition", "(", "float", "x", ",", "float", "y", ",", "boolean", "moveParticles", ")", "{", "if", "(", "moveParticles", ")", "{", "adjust", "=", "true", ";", "adjustx", "-=", "this", ".", "x", "-", "x", ";", "adjusty", "-=", "this", ".", "y", "-", "y", ";", "}", "this", ".", "x", "=", "x", ";", "this", ".", "y", "=", "y", ";", "}" ]

[ "Set", "the", "position", "of", "this", "particle", "source" ]

[ "public", "boolean", "completed", "(", ")", "{", "if", "(", "engine", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "length", ".", "isEnabled", "(", ")", ")", "{", "if", "(", "timeout", ">", "0", ")", "{", "return", "false", ";", "}", "return", "completed", ";", "}", "if", "(", "emitCount", ".", "isEnabled", "(", ")", ")", "{", "if", "(", "leftToEmit", ">", "0", ")", "{", "return", "false", ";", "}", "return", "completed", ";", "}", "if", "(", "wrapUp", ")", "{", "return", "completed", ";", "}", "return", "false", ";", "}" ]

[ "Check", "if", "this", "emitter", "has", "completed", "it", "s", "cycle" ]

[ "public", "ConfigurableEmitter", "duplicate", "(", ")", "{", "ConfigurableEmitter", "theCopy", "=", "null", ";", "try", "{", "ByteArrayOutputStream", "bout", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "ParticleIO", ".", "saveEmitter", "(", "bout", ",", "this", ")", ";", "ByteArrayInputStream", "bin", "=", "new", "ByteArrayInputStream", "(", "bout", ".", "toByteArray", "(", ")", ")", ";", "theCopy", "=", "ParticleIO", ".", "loadEmitter", "(", "bin", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "Log", ".", "error", "(", "\"Slick: ConfigurableEmitter.duplicate(): caught exception \"", "+", "e", ".", "toString", "(", ")", ")", ";", "return", "null", ";", "}", "return", "theCopy", ";", "}" ]

[ "Create", "a", "duplicate", "of", "this", "emitter", ".", "The", "duplicate", "should", "be", "added", "to", "a", "ParticleSystem", "to", "be", "used", "." ]

[ "public", "static", "void", "runAsApplication", "(", "Game", "game", ",", "int", "width", ",", "int", "height", ",", "boolean", "fullscreen", ")", "{", "try", "{", "AppGameContainer", "container", "=", "new", "AppGameContainer", "(", "game", ",", "width", ",", "height", ",", "fullscreen", ")", ";", "container", ".", "start", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "Start", "the", "game", "as", "an", "application" ]

[ "public", "void", "setX", "(", "float", "x", ")", "{", "if", "(", "x", "!=", "this", ".", "x", ")", "{", "float", "dx", "=", "x", "-", "this", ".", "x", ";", "this", ".", "x", "=", "x", ";", "if", "(", "(", "points", "==", "null", ")", "||", "(", "center", "==", "null", ")", ")", "{", "checkPoints", "(", ")", ";", "}", "// update the points in the special case\r", "for", "(", "int", "i", "=", "0", ";", "i", "<", "points", ".", "length", "/", "2", ";", "i", "++", ")", "{", "points", "[", "i", "*", "2", "]", "+=", "dx", ";", "}", "center", "[", "0", "]", "+=", "dx", ";", "x", "+=", "dx", ";", "maxX", "+=", "dx", ";", "minX", "+=", "dx", ";", "trianglesDirty", "=", "true", ";", "}", "}" ]

[ "Set", "the", "x", "position", "of", "the", "left", "side", "this", "shape", "." ]

[ "public", "void", "setY", "(", "float", "y", ")", "{", "if", "(", "y", "!=", "this", ".", "y", ")", "{", "float", "dy", "=", "y", "-", "this", ".", "y", ";", "this", ".", "y", "=", "y", ";", "if", "(", "(", "points", "==", "null", ")", "||", "(", "center", "==", "null", ")", ")", "{", "checkPoints", "(", ")", ";", "}", "// update the points in the special case\r", "for", "(", "int", "i", "=", "0", ";", "i", "<", "points", ".", "length", "/", "2", ";", "i", "++", ")", "{", "points", "[", "(", "i", "*", "2", ")", "+", "1", "]", "+=", "dy", ";", "}", "center", "[", "1", "]", "+=", "dy", ";", "y", "+=", "dy", ";", "maxY", "+=", "dy", ";", "minY", "+=", "dy", ";", "trianglesDirty", "=", "true", ";", "}", "}" ]

[ "Set", "the", "y", "position", "of", "the", "top", "of", "this", "shape", "." ]

[ "public", "void", "setCenterX", "(", "float", "centerX", ")", "{", "if", "(", "(", "points", "==", "null", ")", "||", "(", "center", "==", "null", ")", ")", "{", "checkPoints", "(", ")", ";", "}", "float", "xDiff", "=", "centerX", "-", "getCenterX", "(", ")", ";", "setX", "(", "x", "+", "xDiff", ")", ";", "}" ]

[ "Set", "the", "x", "center", "of", "this", "shape", "." ]

[ "public", "void", "setCenterY", "(", "float", "centerY", ")", "{", "if", "(", "(", "points", "==", "null", ")", "||", "(", "center", "==", "null", ")", ")", "{", "checkPoints", "(", ")", ";", "}", "float", "yDiff", "=", "centerY", "-", "getCenterY", "(", ")", ";", "setY", "(", "y", "+", "yDiff", ")", ";", "}" ]

[ "Set", "the", "y", "center", "of", "this", "shape", "." ]

[ "public", "float", "[", "]", "getPoint", "(", "int", "index", ")", "{", "checkPoints", "(", ")", ";", "float", "result", "[", "]", "=", "new", "float", "[", "2", "]", ";", "result", "[", "0", "]", "=", "points", "[", "index", "*", "2", "]", ";", "result", "[", "1", "]", "=", "points", "[", "index", "*", "2", "+", "1", "]", ";", "return", "result", ";", "}" ]

[ "Get", "a", "single", "point", "in", "this", "polygon" ]

[ "public", "float", "[", "]", "getNormal", "(", "int", "index", ")", "{", "float", "[", "]", "current", "=", "getPoint", "(", "index", ")", ";", "float", "[", "]", "prev", "=", "getPoint", "(", "index", "-", "1", "<", "0", "?", "getPointCount", "(", ")", "-", "1", ":", "index", "-", "1", ")", ";", "float", "[", "]", "next", "=", "getPoint", "(", "index", "+", "1", ">=", "getPointCount", "(", ")", "?", "0", ":", "index", "+", "1", ")", ";", "float", "[", "]", "t1", "=", "getNormal", "(", "prev", ",", "current", ")", ";", "float", "[", "]", "t2", "=", "getNormal", "(", "current", ",", "next", ")", ";", "if", "(", "(", "index", "==", "0", ")", "&&", "(", "!", "closed", "(", ")", ")", ")", "{", "return", "t2", ";", "}", "if", "(", "(", "index", "==", "getPointCount", "(", ")", "-", "1", ")", "&&", "(", "!", "closed", "(", ")", ")", ")", "{", "return", "t1", ";", "}", "float", "tx", "=", "(", "t1", "[", "0", "]", "+", "t2", "[", "0", "]", ")", "/", "2", ";", "float", "ty", "=", "(", "t1", "[", "1", "]", "+", "t2", "[", "1", "]", ")", "/", "2", ";", "float", "len", "=", "(", "float", ")", "Math", ".", "sqrt", "(", "(", "tx", "*", "tx", ")", "+", "(", "ty", "*", "ty", ")", ")", ";", "return", "new", "float", "[", "]", "{", "tx", "/", "len", ",", "ty", "/", "len", "}", ";", "}" ]

[ "Get", "the", "combine", "normal", "of", "a", "given", "point" ]

[ "public", "boolean", "contains", "(", "Shape", "other", ")", "{", "if", "(", "other", ".", "intersects", "(", "this", ")", ")", "{", "return", "false", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "other", ".", "getPointCount", "(", ")", ";", "i", "++", ")", "{", "float", "[", "]", "pt", "=", "other", ".", "getPoint", "(", "i", ")", ";", "if", "(", "!", "contains", "(", "pt", "[", "0", "]", ",", "pt", "[", "1", "]", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Check", "if", "the", "shape", "passed", "is", "entirely", "contained", "within", "this", "shape", "." ]

[ "private", "float", "[", "]", "getNormal", "(", "float", "[", "]", "start", ",", "float", "[", "]", "end", ")", "{", "float", "dx", "=", "start", "[", "0", "]", "-", "end", "[", "0", "]", ";", "float", "dy", "=", "start", "[", "1", "]", "-", "end", "[", "1", "]", ";", "float", "len", "=", "(", "float", ")", "Math", ".", "sqrt", "(", "(", "dx", "*", "dx", ")", "+", "(", "dy", "*", "dy", ")", ")", ";", "dx", "/=", "len", ";", "dy", "/=", "len", ";", "return", "new", "float", "[", "]", "{", "-", "dy", ",", "dx", "}", ";", "}" ]

[ "Get", "the", "normal", "of", "the", "line", "between", "two", "points" ]

[ "public", "boolean", "includes", "(", "float", "x", ",", "float", "y", ")", "{", "if", "(", "points", ".", "length", "==", "0", ")", "{", "return", "false", ";", "}", "checkPoints", "(", ")", ";", "Line", "testLine", "=", "new", "Line", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "Vector2f", "pt", "=", "new", "Vector2f", "(", "x", ",", "y", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "points", ".", "length", ";", "i", "+=", "2", ")", "{", "int", "n", "=", "i", "+", "2", ";", "if", "(", "n", ">=", "points", ".", "length", ")", "{", "n", "=", "0", ";", "}", "testLine", ".", "set", "(", "points", "[", "i", "]", ",", "points", "[", "i", "+", "1", "]", ",", "points", "[", "n", "]", ",", "points", "[", "n", "+", "1", "]", ")", ";", "if", "(", "testLine", ".", "on", "(", "pt", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "if", "the", "given", "point", "is", "part", "of", "the", "path", "that", "forms", "this", "shape" ]

[ "public", "int", "indexOf", "(", "float", "x", ",", "float", "y", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "points", ".", "length", ";", "i", "+=", "2", ")", "{", "if", "(", "(", "points", "[", "i", "]", "==", "x", ")", "&&", "(", "points", "[", "i", "+", "1", "]", "==", "y", ")", ")", "{", "return", "i", "/", "2", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Get", "the", "index", "of", "a", "given", "point" ]

[ "public", "boolean", "contains", "(", "float", "x", ",", "float", "y", ")", "{", "checkPoints", "(", ")", ";", "if", "(", "points", ".", "length", "==", "0", ")", "{", "return", "false", ";", "}", "boolean", "result", "=", "false", ";", "float", "xnew", ",", "ynew", ";", "float", "xold", ",", "yold", ";", "float", "x1", ",", "y1", ";", "float", "x2", ",", "y2", ";", "int", "npoints", "=", "points", ".", "length", ";", "xold", "=", "points", "[", "npoints", "-", "2", "]", ";", "yold", "=", "points", "[", "npoints", "-", "1", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "npoints", ";", "i", "+=", "2", ")", "{", "xnew", "=", "points", "[", "i", "]", ";", "ynew", "=", "points", "[", "i", "+", "1", "]", ";", "if", "(", "xnew", ">", "xold", ")", "{", "x1", "=", "xold", ";", "x2", "=", "xnew", ";", "y1", "=", "yold", ";", "y2", "=", "ynew", ";", "}", "else", "{", "x1", "=", "xnew", ";", "x2", "=", "xold", ";", "y1", "=", "ynew", ";", "y2", "=", "yold", ";", "}", "if", "(", "(", "xnew", "<", "x", ")", "==", "(", "x", "<=", "xold", ")", "/* edge \"open\" at one end */", "&&", "(", "(", "double", ")", "y", "-", "(", "double", ")", "y1", ")", "*", "(", "x2", "-", "x1", ")", "<", "(", "(", "double", ")", "y2", "-", "(", "double", ")", "y1", ")", "*", "(", "x", "-", "x1", ")", ")", "{", "result", "=", "!", "result", ";", "}", "xold", "=", "xnew", ";", "yold", "=", "ynew", ";", "}", "return", "result", ";", "}" ]

[ "Check", "if", "this", "polygon", "contains", "the", "given", "point" ]

[ "public", "boolean", "intersects", "(", "Shape", "shape", ")", "{", "/*\r\n * Intersection formula used:\r\n * (x4 - x3)(y1 - y3) - (y4 - y3)(x1 - x3)\r\n * UA = ---------------------------------------\r\n * (y4 - y3)(x2 - x1) - (x4 - x3)(y2 - y1)\r\n * \r\n * (x2 - x1)(y1 - y3) - (y2 - y1)(x1 - x3)\r\n * UB = ---------------------------------------\r\n * (y4 - y3)(x2 - x1) - (x4 - x3)(y2 - y1)\r\n * \r\n * if UA and UB are both between 0 and 1 then the lines intersect.\r\n * \r\n * Source: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/\r\n */", "checkPoints", "(", ")", ";", "boolean", "result", "=", "false", ";", "float", "points", "[", "]", "=", "getPoints", "(", ")", ";", "// (x3, y3) and (x4, y4)\r", "float", "thatPoints", "[", "]", "=", "shape", ".", "getPoints", "(", ")", ";", "// (x1, y1) and (x2, y2)\r", "int", "length", "=", "points", ".", "length", ";", "int", "thatLength", "=", "thatPoints", ".", "length", ";", "double", "unknownA", ";", "double", "unknownB", ";", "if", "(", "!", "closed", "(", ")", ")", "{", "length", "-=", "2", ";", "}", "if", "(", "!", "shape", ".", "closed", "(", ")", ")", "{", "thatLength", "-=", "2", ";", "}", "// x1 = thatPoints[j]\r", "// x2 = thatPoints[j + 2]\r", "// y1 = thatPoints[j + 1]\r", "// y2 = thatPoints[j + 3]\r", "// x3 = points[i]\r", "// x4 = points[i + 2]\r", "// y3 = points[i + 1]\r", "// y4 = points[i + 3]\r", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "+=", "2", ")", "{", "int", "iNext", "=", "i", "+", "2", ";", "if", "(", "iNext", ">=", "points", ".", "length", ")", "{", "iNext", "=", "0", ";", "}", "for", "(", "int", "j", "=", "0", ";", "j", "<", "thatLength", ";", "j", "+=", "2", ")", "{", "int", "jNext", "=", "j", "+", "2", ";", "if", "(", "jNext", ">=", "thatPoints", ".", "length", ")", "{", "jNext", "=", "0", ";", "}", "unknownA", "=", "(", "(", "(", "points", "[", "iNext", "]", "-", "points", "[", "i", "]", ")", "*", "(", "double", ")", "(", "thatPoints", "[", "j", "+", "1", "]", "-", "points", "[", "i", "+", "1", "]", ")", ")", "-", "(", "(", "points", "[", "iNext", "+", "1", "]", "-", "points", "[", "i", "+", "1", "]", ")", "*", "(", "thatPoints", "[", "j", "]", "-", "points", "[", "i", "]", ")", ")", ")", "/", "(", "(", "(", "points", "[", "iNext", "+", "1", "]", "-", "points", "[", "i", "+", "1", "]", ")", "*", "(", "thatPoints", "[", "jNext", "]", "-", "thatPoints", "[", "j", "]", ")", ")", "-", "(", "(", "points", "[", "iNext", "]", "-", "points", "[", "i", "]", ")", "*", "(", "thatPoints", "[", "jNext", "+", "1", "]", "-", "thatPoints", "[", "j", "+", "1", "]", ")", ")", ")", ";", "unknownB", "=", "(", "(", "(", "thatPoints", "[", "jNext", "]", "-", "thatPoints", "[", "j", "]", ")", "*", "(", "double", ")", "(", "thatPoints", "[", "j", "+", "1", "]", "-", "points", "[", "i", "+", "1", "]", ")", ")", "-", "(", "(", "thatPoints", "[", "jNext", "+", "1", "]", "-", "thatPoints", "[", "j", "+", "1", "]", ")", "*", "(", "thatPoints", "[", "j", "]", "-", "points", "[", "i", "]", ")", ")", ")", "/", "(", "(", "(", "points", "[", "iNext", "+", "1", "]", "-", "points", "[", "i", "+", "1", "]", ")", "*", "(", "thatPoints", "[", "jNext", "]", "-", "thatPoints", "[", "j", "]", ")", ")", "-", "(", "(", "points", "[", "iNext", "]", "-", "points", "[", "i", "]", ")", "*", "(", "thatPoints", "[", "jNext", "+", "1", "]", "-", "thatPoints", "[", "j", "+", "1", "]", ")", ")", ")", ";", "if", "(", "unknownA", ">=", "0", "&&", "unknownA", "<=", "1", "&&", "unknownB", ">=", "0", "&&", "unknownB", "<=", "1", ")", "{", "result", "=", "true", ";", "break", ";", "}", "}", "if", "(", "result", ")", "{", "break", ";", "}", "}", "return", "result", ";", "}" ]

[ "Check", "if", "this", "shape", "intersects", "with", "the", "shape", "provided", "." ]

[ "public", "boolean", "hasVertex", "(", "float", "x", ",", "float", "y", ")", "{", "if", "(", "points", ".", "length", "==", "0", ")", "{", "return", "false", ";", "}", "checkPoints", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "points", ".", "length", ";", "i", "+=", "2", ")", "{", "if", "(", "(", "points", "[", "i", "]", "==", "x", ")", "&&", "(", "points", "[", "i", "+", "1", "]", "==", "y", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "if", "a", "particular", "location", "is", "a", "vertex", "of", "this", "polygon" ]