public RMESettings(FileHandle file) {
keys = new ObjectMap<String, int[]>();
keys.put("left", new int[] {Keys.A, Keys.LEFT});
keys.put("up", new int[] {Keys.W, Keys.UP});
keys.put("right", new int[] {Keys.D, Keys.RIGHT});
keys.put("down", new int[] {Keys.S, Keys.DOWN});
Json json = new Json();
json.toJson(this, file);
}
public TiledMap load(String fileName, AtlasTiledMapLoaderParameters parameter) {
try {
if (parameter != null) {
yUp = parameter.yUp;
} else {
yUp = true;
}
FileHandle tmxFile = resolve(fileName);
root = xml.parse(tmxFile);
ObjectMap<String, TextureAtlas> atlases = new ObjectMap<String, TextureAtlas>();
FileHandle atlasFile = loadAtlas(root, tmxFile);
if (atlasFile == null) {
throw new GdxRuntimeException("Couldn't load atlas");
}
TextureAtlas atlas = new TextureAtlas(atlasFile);
atlases.put(atlasFile.path(), atlas);
AtlasResolver.DirectAtlasResolver atlasResolver =
new AtlasResolver.DirectAtlasResolver(atlases);
TiledMap map = loadMap(root, tmxFile, atlasResolver, parameter);
map.setOwnedResources(atlases.values().toArray());
setTextureFilters(parameter.textureMinFilter, parameter.textureMagFilter);
return map;
} catch (IOException e) {
throw new GdxRuntimeException("Couldn't load tilemap '" + fileName + "'", e);
}
}
protected void processDir(Entry inputDir, ArrayList<Entry> files) throws Exception {
// Start with a copy of a parent dir's settings or the default settings.
Settings settings = null;
File parent = inputDir.inputFile;
while (true) {
if (parent.equals(root)) break;
parent = parent.getParentFile();
settings = dirToSettings.get(parent);
if (settings != null) {
settings = new Settings(settings);
break;
}
}
if (settings == null) settings = new Settings(defaultSettings);
dirToSettings.put(inputDir.inputFile, settings);
// Merge settings from pack.json file.
File settingsFile = new File(inputDir.inputFile, "pack.json");
if (settingsFile.exists())
json.readFields(settings, new JsonReader().parse(new FileReader(settingsFile)));
// Pack.
TexturePacker2 packer = new TexturePacker2(root, settings);
for (Entry file : files) packer.addImage(file.inputFile);
packer.pack(inputDir.outputDir, packFileName);
}
@Override
public void show() {
font =
new BitmapFont(
Gdx.files.internal("assets/font.fnt"), Gdx.files.internal("assets/font.png"), false);
batch = new SpriteBatch();
shapeRenderer = new ShapeRenderer();
bindingButtons = new ObjectMap<String, Rectangle>();
backButton = new Rectangle(40.0f, 730.0f, 100.0f, 32.0f);
// setup interface
ObjectMap.Entries<String, Binding> it = game.getBindings().entries();
float y = 700.0f;
while (it.hasNext()) {
ObjectMap.Entry<String, Binding> entry = it.next();
Rectangle button = new Rectangle(300.0f, y, 150.0f, 32);
y -= 40;
bindingButtons.put(entry.key, button);
}
mousePos = new Vector3();
camera = new OrthographicCamera();
camera.setToOrtho(false);
Gdx.input.setInputProcessor(this);
focusedBox = new Rectangle();
}
public void addAttachment(int slotIndex, String name, Attachment attachment) {
if (attachment == null) throw new IllegalArgumentException("attachment cannot be null.");
if (slotIndex < 0) throw new IllegalArgumentException("slotIndex must be >= 0.");
Key key = new Key();
key.set(slotIndex, name);
attachments.put(key, attachment);
}
public void setMix(Animation from, Animation to, float duration) {
if (from == null) throw new IllegalArgumentException("from cannot be null.");
if (to == null) throw new IllegalArgumentException("to cannot be null.");
Key key = new Key();
key.a1 = from;
key.a2 = to;
animationToMixTime.put(key, duration);
}
@Override
protected void next(final ObjectMap<String, String> arguments) {
for (int arrayId = 0, length = indexes.size; arrayId < length; arrayId++) {
arguments.put(argumentNames.get(arrayId), values.get(arrayId)[indexes.get(arrayId)]);
}
incrementIndex(indexes.size - 1);
currentIndex++;
}
@Override
public void createUI(ATVector2Array annotation, Field field, Class<?> fieldType) {
Vector2ArrayView view = new Vector2ArrayView();
views.put(field, view);
uiTable.add(annotation.fieldName()).spaceBottom(3).row();
uiTable.add(view).expandX().fillX().row();
}
@Override
public Preferences getPreferences(String name) {
Preferences pref = prefs.get(name);
if (pref == null) {
pref = new GwtPreferences(name);
prefs.put(name, pref);
}
return pref;
}
@Override
public Preferences getPreferences(String name) {
if (preferences.containsKey(name)) {
return preferences.get(name);
} else {
Preferences prefs = new LwjglPreferences(name);
preferences.put(name, prefs);
return prefs;
}
}
@Override
public void createUI(ATStringStringMap annotation, Field field, Class<?> fieldType)
throws ReflectiveOperationException {
StringStringMapView view = new StringStringMapView("No variables", properties);
views.put(field, view);
if (annotation.fieldName().equals("") == false)
uiTable.add(annotation.fieldName()).spaceBottom(3);
uiTable.row();
uiTable.add(view).expandX().fillX().row();
}
private Material convertMaterial(ModelMaterial mtl, TextureProvider textureProvider) {
Material result = new Material();
result.id = mtl.id;
if (mtl.ambient != null) result.set(new ColorAttribute(ColorAttribute.Ambient, mtl.ambient));
if (mtl.diffuse != null) result.set(new ColorAttribute(ColorAttribute.Diffuse, mtl.diffuse));
if (mtl.specular != null) result.set(new ColorAttribute(ColorAttribute.Specular, mtl.specular));
if (mtl.emissive != null) result.set(new ColorAttribute(ColorAttribute.Emissive, mtl.emissive));
if (mtl.reflection != null)
result.set(new ColorAttribute(ColorAttribute.Reflection, mtl.reflection));
if (mtl.shininess > 0f) result.set(new FloatAttribute(FloatAttribute.Shininess, mtl.shininess));
if (mtl.opacity != 1.f)
result.set(
new BlendingAttribute(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA, mtl.opacity));
ObjectMap<String, Texture> textures = new ObjectMap<String, Texture>();
// FIXME mipmapping totally ignored, filters totally ignored, uvScaling/uvTranslation totally
// ignored
if (mtl.textures != null) {
for (ModelTexture tex : mtl.textures) {
Texture texture;
if (textures.containsKey(tex.fileName)) {
texture = textures.get(tex.fileName);
} else {
texture = textureProvider.load(tex.fileName);
textures.put(tex.fileName, texture);
disposables.add(texture);
}
TextureDescriptor descriptor = new TextureDescriptor(texture);
descriptor.minFilter = Texture.TextureFilter.Linear;
descriptor.magFilter = Texture.TextureFilter.Linear;
descriptor.uWrap = Texture.TextureWrap.Repeat;
descriptor.vWrap = Texture.TextureWrap.Repeat;
switch (tex.usage) {
case ModelTexture.USAGE_DIFFUSE:
result.set(new TextureAttribute(TextureAttribute.Diffuse, descriptor));
break;
case ModelTexture.USAGE_SPECULAR:
result.set(new TextureAttribute(TextureAttribute.Specular, descriptor));
break;
case ModelTexture.USAGE_BUMP:
result.set(new TextureAttribute(TextureAttribute.Bump, descriptor));
break;
case ModelTexture.USAGE_NORMAL:
result.set(new TextureAttribute(TextureAttribute.Normal, descriptor));
break;
}
}
}
return result;
}
@Override
public Preferences getPreferences(String name) {
if (preferences.containsKey(name)) {
return preferences.get(name);
} else {
Preferences prefs =
new Lwjgl3Preferences(
new Lwjgl3FileHandle(
new File(config.preferencesDirectory, name), config.preferencesFileType));
preferences.put(name, prefs);
return prefs;
}
}
private void loadWeapons() {
logger.debug("Loading Weapons");
Json json = new Json();
for (String s : manifest.weapons) {
try {
WeaponConfig config = json.fromJson(WeaponConfig.class, Gdx.files.internal(s));
weaponConfigs.put(config.name, config);
} catch (SerializationException ex) {
logger.error("Failed to load weapons file: " + s);
logger.error(ex.getMessage());
}
}
}
private void loadEntities() {
logger.debug("Loading Entities");
Json json = new Json();
for (String s : manifest.entities) {
try {
EntityConfig config = json.fromJson(EntityConfig.class, Gdx.files.internal(s));
entityConfigs.put(config.name, config);
} catch (SerializationException ex) {
logger.error("Failed to load entity file: " + s);
logger.error(ex.getMessage());
}
}
}
public void updateBinding(int keycode) {
ObjectMap<String, Binding> bindings = game.getBindings();
Binding binding = bindings.get(this.focusedAction);
String character = game.map.get(keycode);
if (character != null) {
binding.character = character;
binding.keyCode = keycode;
System.out.println(
"Updating action: " + this.focusedAction + " to " + keycode + " " + binding.character);
bindings.put(focusedAction, binding);
} else {
System.out.println("Couldnt map character: " + keycode);
}
}
private TextureRegion getCachedGfxRegion(TextureRegionAsset asset) {
String relativePath = asset.getPath();
String regionName = FileUtils.removeFirstSeparator(FilenameUtils.removeExtension(relativePath));
TextureRegion region = regions.get(regionName);
if (region == null) {
if (cache != null) region = cache.findRegion(regionName);
if (region == null) region = new TextureRegion(loadingRegion);
regions.put(relativePath, region);
}
return region;
}
public static void render(DebugRenderContext context, AudioSourceComponent sourceComponent) {
Application app = Gdx.app;
if (app == null) {
return;
}
AudioDebugRenderer renderer = instances.get(app);
if (renderer == null) {
renderer = new AudioDebugRenderer();
instances.put(app, renderer);
}
renderer.renderSource(context, sourceComponent);
}
private void updateAtlas(FileHandle file) {
String relativePath = fileAccess.relativizeToAssetsFolder(file);
TextureAtlas atlas = atlases.get(relativePath);
if (atlas != null) {
atlases.remove(relativePath);
atlas.dispose();
}
if (file.exists()) {
atlases.put(relativePath, new TextureAtlas(file));
App.eventBus.post(new ResourceReloadedEvent(ResourceReloadedEvent.RESOURCE_TEXTURES));
App.eventBus.post(new ResourceReloadedEvent(ResourceReloadedEvent.RESOURCE_TEXTURE_ATLASES));
}
}
public TiledMap load(String fileName) {
try {
FileHandle tideFile = resolve(fileName);
root = xml.parse(tideFile);
ObjectMap<String, Texture> textures = new ObjectMap<String, Texture>();
for (FileHandle textureFile : loadTileSheets(root, tideFile)) {
textures.put(textureFile.path(), new Texture(textureFile));
}
DirectImageResolver imageResolver = new DirectImageResolver(textures);
TiledMap map = loadMap(root, tideFile, imageResolver);
map.setOwnedResources(textures.values().toArray());
return map;
} catch (IOException e) {
throw new GdxRuntimeException("Couldn't load tilemap '" + fileName + "'", e);
}
}
/**
* Helper method to apply one animation to either an objectmap for blending or directly to the
* bones.
*/
protected static void applyAnimation(
final ObjectMap<Node, Transform> out,
final Pool<Transform> pool,
final float alpha,
final Animation animation,
final float time) {
for (final NodeAnimation nodeAnim : animation.nodeAnimations) {
final Node node = nodeAnim.node;
node.isAnimated = true;
// Find the keyframe(s)
final int n = nodeAnim.keyframes.size - 1;
int first = 0, second = -1;
for (int i = 0; i < n; i++) {
if (time >= nodeAnim.keyframes.get(i).keytime
&& time <= nodeAnim.keyframes.get(i + 1).keytime) {
first = i;
second = i + 1;
break;
}
}
// Apply the first keyframe:
final Transform transform = tmpT;
final NodeKeyframe firstKeyframe = nodeAnim.keyframes.get(first);
transform.set(firstKeyframe.translation, firstKeyframe.rotation, firstKeyframe.scale);
// Lerp the second keyframe
if (second > first) {
final NodeKeyframe secondKeyframe = nodeAnim.keyframes.get(second);
final float t =
(time - firstKeyframe.keytime) / (secondKeyframe.keytime - firstKeyframe.keytime);
transform.lerp(
secondKeyframe.translation, secondKeyframe.rotation, secondKeyframe.scale, t);
}
// Apply the transform, either directly to the bone or to out when blending
if (out == null) transform.toMatrix4(node.localTransform);
else {
if (out.containsKey(node)) {
if (alpha == 1.f) out.get(node).set(transform);
else out.get(node).lerp(transform, alpha);
} else {
out.put(node, pool.obtain().set(transform));
}
}
}
}
public void setObject(Actor actor, Object object) {
values.put(actor, object);
}
@Override
public void sendHttpRequest(
final HttpRequest httpRequest, final HttpResponseListener httpResultListener) {
if (httpRequest.getUrl() == null) {
httpResultListener.failed(
new GdxRuntimeException("can't process a HTTP request without URL set"));
return;
}
final String method = httpRequest.getMethod();
final String value = httpRequest.getContent();
final boolean valueInBody =
method.equalsIgnoreCase(HttpMethods.POST) || method.equals(HttpMethods.PUT);
RequestBuilder builder;
String url = httpRequest.getUrl();
if (method.equalsIgnoreCase(HttpMethods.GET)) {
if (value != null) {
url += "?" + value;
}
builder = new RequestBuilder(RequestBuilder.GET, url);
} else if (method.equalsIgnoreCase(HttpMethods.POST)) {
builder = new RequestBuilder(RequestBuilder.POST, url);
} else if (method.equalsIgnoreCase(HttpMethods.DELETE)) {
if (value != null) {
url += "?" + value;
}
builder = new RequestBuilder(RequestBuilder.DELETE, url);
} else if (method.equalsIgnoreCase(HttpMethods.PUT)) {
builder = new RequestBuilder(RequestBuilder.PUT, url);
} else {
throw new GdxRuntimeException("Unsupported HTTP Method");
}
Map<String, String> content = httpRequest.getHeaders();
Set<String> keySet = content.keySet();
for (String name : keySet) {
builder.setHeader(name, content.get(name));
}
builder.setTimeoutMillis(httpRequest.getTimeOut());
try {
Request request =
builder.sendRequest(
valueInBody ? value : null,
new RequestCallback() {
@Override
public void onResponseReceived(Request request, Response response) {
httpResultListener.handleHttpResponse(new HttpClientResponse(response));
requests.remove(httpRequest);
listeners.remove(httpRequest);
}
@Override
public void onError(Request request, Throwable exception) {
httpResultListener.failed(exception);
requests.remove(httpRequest);
listeners.remove(httpRequest);
}
});
requests.put(httpRequest, request);
listeners.put(httpRequest, httpResultListener);
} catch (Throwable e) {
httpResultListener.failed(e);
}
}
private TurnAction(String name) {
this.name = name;
values.put(name, this);
}
public void putHttpResponse(String URL, Object object) {
httpResponses.put(URL, object);
}
static {
metas = new ObjectSet<>();
META = new ObjectMap<>();
PMETA = new ObjectMap<>();
METATABLES = new ObjectMap<>();
GLOBAL_METATABLE = new ObjectMap<>();
EMPTY_METATABLE = new LuaTable();
// Metamethods implementation for all LuaObjectValues.
GLOBAL_METATABLE.put(
LuaValue.EQ.tojstring(),
LuaUtil.asFunction(
vargs -> {
if (vargs.isnil(2)) {
// We'll still get called for nil. Automagically return false for nil.
return LuaValue.valueOf(false);
}
// obj1, us, is guaranteed to be an object value
LuaObjectValue<? super Object> obj1 = (LuaObjectValue<? super Object>) vargs.arg(1);
LuaValue obj2 = vargs.arg(2);
if (obj2 instanceof LuaObjectValue) {
return LuaValue.valueOf(
obj1.getObject() == ((LuaObjectValue<? super Object>) obj2).getObject());
}
return LuaValue.valueOf(false);
}));
loadMeta(LuaAudioDataMeta.class);
loadMeta(LuaAudioMeta.class);
loadMeta(LuaAudioPlayableMeta.class);
loadMeta(LuaColliderMeta.class);
loadMeta(LuaColorMeta.class);
loadMeta(LuaDestructibleMeta.class);
loadMeta(LuaEnvironmentMeta.class);
loadMeta(LuaEventListenerMeta.class);
loadMeta(LuaFontMeta.class);
loadMeta(LuaIdentifiableMeta.class);
loadMeta(LuaInputDataMeta.class);
loadMeta(LuaLayerableMeta.class);
loadMeta(LuaMusicMeta.class);
loadMeta(LuaOverworldControllerMeta.class);
loadMeta(LuaPositionableMeta.class);
loadMeta(LuaPressDataMeta.class);
loadMeta(LuaProcessableMeta.class);
loadMeta(LuaRenderableMeta.class);
loadMeta(LuaSchedulerMeta.class);
loadMeta(LuaSoundDataMeta.class);
loadMeta(LuaSoundMeta.class);
loadMeta(LuaSpriteMeta.class);
loadMeta(LuaSubsystemMeta.class);
loadMeta(LuaTextComponentMeta.class);
loadMeta(LuaTextMeta.class);
loadMeta(LuaTextStyleMeta.class);
loadMeta(LuaTransformMeta.class);
loadMeta(LuaUIComponentMeta.class);
loadMeta(LuaUIControllerMeta.class);
loadMeta(LuaUIObjectMeta.class);
loadMeta(LuaWorldObjectMeta.class);
loadMeta(new LuaWorldRoomMeta(Undertailor.getInstance()));
log.info("Finished loading lua object metadata");
log.info("Primary types list: ");
Lua.PMETA
.values()
.forEach(
meta -> {
log.info(meta.getClass().getSimpleName());
});
}
public void putDefaultHttpResponse(Object object) {
httpResponses.put(DEFAULT_RESPONSE, object);
}
public void afegirImatge(String descripcio, Texture imatge) {
imatges.put(descripcio, imatge);
}
protected Material convertMaterial(ModelMaterial mtl, TextureProvider textureProvider) {
Material result = new Material();
result.id = mtl.id;
if (mtl.ambient != null) result.set(new ColorAttribute(ColorAttribute.Ambient, mtl.ambient));
if (mtl.diffuse != null) result.set(new ColorAttribute(ColorAttribute.Diffuse, mtl.diffuse));
if (mtl.specular != null) result.set(new ColorAttribute(ColorAttribute.Specular, mtl.specular));
if (mtl.emissive != null) result.set(new ColorAttribute(ColorAttribute.Emissive, mtl.emissive));
if (mtl.reflection != null)
result.set(new ColorAttribute(ColorAttribute.Reflection, mtl.reflection));
if (mtl.shininess > 0f) result.set(new FloatAttribute(FloatAttribute.Shininess, mtl.shininess));
if (mtl.opacity != 1.f)
result.set(
new BlendingAttribute(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA, mtl.opacity));
ObjectMap<String, Texture> textures = new ObjectMap<String, Texture>();
// FIXME uvScaling/uvTranslation totally ignored
if (mtl.textures != null) {
for (ModelTexture tex : mtl.textures) {
Texture texture;
if (textures.containsKey(tex.fileName)) {
texture = textures.get(tex.fileName);
} else {
texture = textureProvider.load(tex.fileName);
textures.put(tex.fileName, texture);
disposables.add(texture);
}
TextureDescriptor descriptor = new TextureDescriptor(texture);
descriptor.minFilter = texture.getMinFilter();
descriptor.magFilter = texture.getMagFilter();
descriptor.uWrap = texture.getUWrap();
descriptor.vWrap = texture.getVWrap();
float offsetU = tex.uvTranslation == null ? 0f : tex.uvTranslation.x;
float offsetV = tex.uvTranslation == null ? 0f : tex.uvTranslation.y;
float scaleU = tex.uvScaling == null ? 1f : tex.uvScaling.x;
float scaleV = tex.uvScaling == null ? 1f : tex.uvScaling.y;
switch (tex.usage) {
case ModelTexture.USAGE_DIFFUSE:
result.set(
new TextureAttribute(
TextureAttribute.Diffuse, descriptor, offsetU, offsetV, scaleU, scaleV));
break;
case ModelTexture.USAGE_SPECULAR:
result.set(
new TextureAttribute(
TextureAttribute.Specular, descriptor, offsetU, offsetV, scaleU, scaleV));
break;
case ModelTexture.USAGE_BUMP:
result.set(
new TextureAttribute(
TextureAttribute.Bump, descriptor, offsetU, offsetV, scaleU, scaleV));
break;
case ModelTexture.USAGE_NORMAL:
result.set(
new TextureAttribute(
TextureAttribute.Normal, descriptor, offsetU, offsetV, scaleU, scaleV));
break;
case ModelTexture.USAGE_AMBIENT:
result.set(
new TextureAttribute(
TextureAttribute.Ambient, descriptor, offsetU, offsetV, scaleU, scaleV));
break;
case ModelTexture.USAGE_EMISSIVE:
result.set(
new TextureAttribute(
TextureAttribute.Emissive, descriptor, offsetU, offsetV, scaleU, scaleV));
break;
case ModelTexture.USAGE_REFLECTION:
result.set(
new TextureAttribute(
TextureAttribute.Reflection, descriptor, offsetU, offsetV, scaleU, scaleV));
break;
}
}
}
return result;
}
