e.printStackTrace();
exit();
}
- CaveGame caveGame = new CaveGame(gameFolder, true);
+ CaveGame caveGame = new CaveGame(gameFolder, true, null);
caveGame.setDebug(BuildConfig.DEBUG);
initialize(caveGame, config);
}
import ru.deadsoftware.cavedroid.game.GameItems;
import ru.deadsoftware.cavedroid.game.GameScreen;
import ru.deadsoftware.cavedroid.misc.Assets;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
+
+import javax.annotation.Nullable;
public class CaveGame extends Game {
private final MainConfig mMainConfig;
private final MainComponent mMainComponent;
+ private final AssetLoader mAssetLoader;
private final String mGameFolder;
private final boolean mTouch;
private boolean mDebug;
- public CaveGame(String gameFolder, boolean touch) {
+ @Nullable
+ private final String mAssetsPackPath;
+
+ public CaveGame(String gameFolder, boolean touch, @Nullable String assetsPackPath) {
mGameFolder = gameFolder;
mTouch = touch;
+ mAssetsPackPath = assetsPackPath;
mMainComponent = DaggerMainComponent.builder().caveGame(this).build();
+
mMainConfig = mMainComponent.getMainConfig();
+ mAssetLoader = mMainComponent.getAssetLoader();
}
public void setDebug(boolean debug) {
mMainConfig.setWidth(width);
mMainConfig.setHeight(height);
mMainConfig.setShowInfo(mDebug);
+ mMainConfig.setAssetsPackPath(mAssetsPackPath);
}
public void newGame() {
Gdx.app.log(TAG, mGameFolder);
Gdx.files.absolute(mGameFolder).mkdirs();
- Assets.load();
- GameItems.load();
-
initConfig();
+ Assets.load(mAssetLoader);
+ GameItems.load(mAssetLoader);
+
setScreen(mMainComponent.getMenuScreen());
}
import dagger.Component;
import ru.deadsoftware.cavedroid.game.GameScreen;
import ru.deadsoftware.cavedroid.menu.MenuScreen;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
import javax.inject.Singleton;
MenuScreen getMenuScreen();
MainConfig getMainConfig();
+
+ AssetLoader getAssetLoader();
}
import ru.deadsoftware.cavedroid.game.GameUiWindow;
import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
import javax.inject.Inject;
import javax.inject.Singleton;
private float mWidth;
private float mHeight;
+ @Nullable
+ private String mAssetsPackPath = null;
+
@Inject
public MainConfig(CaveGame caveGame) {
mCaveGame = caveGame;
public void setShowMap(boolean showMap) {
mShowMap = showMap;
}
+
+ @Nullable
+ public String getAssetsPackPath() {
+ return mAssetsPackPath;
+ }
+
+ public void setAssetsPackPath(@Nullable String assetsPackPath) {
+ mAssetsPackPath = assetsPackPath;
+ }
}
import ru.deadsoftware.cavedroid.MainConfig;
import ru.deadsoftware.cavedroid.game.objects.TouchButton;
import ru.deadsoftware.cavedroid.misc.Assets;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
import javax.inject.Inject;
private final GameInput mGameInput;
private final GameRenderer mGameRenderer;
private final MainConfig mMainConfig;
+ private final AssetLoader mAssetLoader;
@Inject
public GameInputProcessor(GameInput gameInput,
GameRenderer gameRenderer,
- MainConfig mainConfig) {
+ MainConfig mainConfig,
+ AssetLoader assetLoader) {
mGameInput = gameInput;
mGameRenderer = gameRenderer;
mMainConfig = mainConfig;
+ mAssetLoader = assetLoader;
loadTouchButtonsFromJSON();
}
}
private void loadTouchButtonsFromJSON() {
- JsonValue json = Assets.jsonReader.parse(Gdx.files.internal("json/touch_buttons.json"));
+ JsonValue json = Assets.jsonReader.parse(mAssetLoader.getAssetHandle("json/touch_buttons.json"));
for (JsonValue key = json.child(); key != null; key = key.next()) {
float x = key.getFloat("x");
float y = key.getFloat("y");
import ru.deadsoftware.cavedroid.game.objects.Block;
import ru.deadsoftware.cavedroid.game.objects.Item;
import ru.deadsoftware.cavedroid.misc.Assets;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
import java.util.HashMap;
return items.getValueAt(id).getType().equals("block") ? getBlockTex(id) : getItem(id).getTexture();
}
- public static void load() {
- JsonValue json = Assets.jsonReader.parse(Gdx.files.internal("json/game_items.json"));
+ public static void load(AssetLoader assetLoader) {
+ JsonValue json = Assets.jsonReader.parse(assetLoader.getAssetHandle("json/game_items.json"));
for (JsonValue block = json.get("blocks").child(); block != null; block = block.next()) {
try {
String key = block.name();
String meta = Assets.getStringFromJson(block, "meta", "");
String tex = Assets.getStringFromJson(block, "texture", key);
Texture texture = tex.equals("none") ? null :
- new Texture(Gdx.files.internal("textures/blocks/" + tex + ".png"));
+ new Texture(assetLoader.getAssetHandle("textures/blocks/" + tex + ".png"));
boolean animated = Assets.getBooleanFromJson(block, "animated", false);
int frames = Assets.getIntFromJson(block, "frames", 0);
String type = Assets.getStringFromJson(item, "type", "item");
String texture = Assets.getStringFromJson(item, "texture", key);
Sprite sprite = type.equals("block") ? null :
- new Sprite(new Texture(Gdx.files.internal("textures/items/" + texture + ".png")));
+ new Sprite(new Texture(assetLoader.getAssetHandle("textures/items/" + texture + ".png")));
itemsIds.put(key, items.size);
items.put(key, new Item(name, type, sprite));
} catch (GdxRuntimeException e) {
changeDir();
}
}
-
- if (mVelocity.x != 0f) {
- mAnim += mAnimDelta * delta;
- } else {
- mAnim = 0;
- }
-
- if (mAnim >= 60 || mAnim <= -60) {
- mAnimDelta = -mAnimDelta;
- }
}
@Override
private Menu mCurrentMenu;
@Inject
- public MenuProc(MainConfig mainConfig) {
+ public MenuProc(
+ MainConfig mainConfig,
+ MenuMain.Factory menuMainFactory,
+ MenuNewGame.Factory menuNewGameFactory
+ ) {
super(mainConfig.getWidth(), mainConfig.getHeight());
mMainConfig = mainConfig;
Input menuInput = new Input();
- mMenuMain = new MenuMain(getWidth(), getHeight(), this::drawButton, mainConfig, menuInput);
- mMenuNewGame = new MenuNewGame(getWidth(), getHeight(), this::drawButton, mainConfig, menuInput);
+ mMenuMain = menuMainFactory.get(getWidth(), getHeight(), this::drawButton, menuInput);
+ mMenuNewGame = menuNewGameFactory.get(getWidth(), getHeight(), this::drawButton, menuInput);
mCurrentMenu = mMenuMain;
}
import ru.deadsoftware.cavedroid.menu.objects.ButtonEventListener;
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer;
import ru.deadsoftware.cavedroid.misc.Assets;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
import java.util.HashMap;
protected final MainConfig mMainConfig;
protected final MenuProc.Input mMenuInput;
+ protected final AssetLoader mAssetLoader;
private final ButtonRenderer mButtonRenderer;
* @param height Viewport height
* @param buttonRenderer {@link ButtonRenderer} that will draw the buttons of this menu
*/
- Menu(float width, float height, ButtonRenderer buttonRenderer, MainConfig mainConfig, MenuProc.Input menuInput) {
+ Menu(float width,
+ float height,
+ ButtonRenderer buttonRenderer,
+ MainConfig mainConfig,
+ MenuProc.Input menuInput,
+ AssetLoader assetLoader) {
mWidth = width;
mHeight = height;
mButtonRenderer = buttonRenderer;
mMainConfig = mainConfig;
mMenuInput = menuInput;
+ mAssetLoader = assetLoader;
initButtons();
}
import ru.deadsoftware.cavedroid.menu.objects.Button;
import ru.deadsoftware.cavedroid.menu.objects.ButtonEventListener;
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
+import javax.inject.Inject;
import java.util.HashMap;
public class MenuMain extends Menu {
- public MenuMain(float width, float height, ButtonRenderer buttonRenderer, MainConfig mainConfig, MenuProc.Input menuInput) {
- super(width, height, buttonRenderer, mainConfig, menuInput);
+ public MenuMain(float width,
+ float height,
+ ButtonRenderer buttonRenderer,
+ MainConfig mainConfig,
+ MenuProc.Input menuInput,
+ AssetLoader assetLoader) {
+ super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader);
}
@Override
@Override
protected void initButtons() {
- loadButtonsFromJson(Gdx.files.internal("json/menu_main_buttons.json"));
+ loadButtonsFromJson(mAssetLoader.getAssetHandle("json/menu_main_buttons.json"));
if (GameSaver.exists(mMainConfig)) {
getButtons().get("load_game").setType(Button.NORMAL);
}
}
+
+ public static class Factory {
+
+ private final MainConfig mMainConfig;
+ private final AssetLoader mAssetLoader;
+
+ @Inject
+ public Factory(MainConfig mainConfig, AssetLoader assetLoader) {
+ mMainConfig = mainConfig;
+ mAssetLoader = assetLoader;
+ }
+
+ public MenuMain get(float width, float height, ButtonRenderer buttonRenderer, MenuProc.Input menuInput) {
+ return new MenuMain(width, height, buttonRenderer, mMainConfig, menuInput, mAssetLoader);
+ }
+
+ }
+
}
package ru.deadsoftware.cavedroid.menu.submenus;
-import com.badlogic.gdx.Gdx;
import ru.deadsoftware.cavedroid.MainConfig;
import ru.deadsoftware.cavedroid.menu.MenuProc;
import ru.deadsoftware.cavedroid.menu.objects.ButtonEventListener;
import ru.deadsoftware.cavedroid.menu.objects.ButtonRenderer;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
+import javax.inject.Inject;
import java.util.HashMap;
public class MenuNewGame extends Menu {
- public MenuNewGame(float width, float height, ButtonRenderer buttonRenderer, MainConfig mainConfig, MenuProc.Input menuInput) {
- super(width, height, buttonRenderer, mainConfig, menuInput);
+ public MenuNewGame(float width,
+ float height,
+ ButtonRenderer buttonRenderer,
+ MainConfig mainConfig,
+ MenuProc.Input menuInput,
+ AssetLoader assetLoader) {
+ super(width, height, buttonRenderer, mainConfig, menuInput, assetLoader);
}
@Override
@Override
protected void initButtons() {
- loadButtonsFromJson(Gdx.files.internal("json/menu_new_game_buttons.json"));
+ loadButtonsFromJson(mAssetLoader.getAssetHandle("json/menu_new_game_buttons.json"));
+ }
+
+ public static class Factory {
+
+ private final MainConfig mMainConfig;
+ private final AssetLoader mAssetLoader;
+
+ @Inject
+ public Factory(MainConfig mainConfig, AssetLoader assetLoader) {
+ mMainConfig = mainConfig;
+ mAssetLoader = assetLoader;
+ }
+
+ public MenuNewGame get(float width, float height, ButtonRenderer buttonRenderer, MenuProc.Input menuInput) {
+ return new MenuNewGame(width, height, buttonRenderer, mMainConfig, menuInput, mAssetLoader);
+ }
+
}
}
import com.badlogic.gdx.utils.JsonReader;
import com.badlogic.gdx.utils.JsonValue;
import ru.deadsoftware.cavedroid.game.objects.TouchButton;
+import ru.deadsoftware.cavedroid.misc.utils.AssetLoader;
import java.util.HashMap;
return sprite;
}
- private static void loadMob(Sprite[][] sprite, String mob) {
+ private static void loadMob(AssetLoader assetLoader, Sprite[][] sprite, String mob) {
for (int i = 0; i < sprite.length; i++) {
for (int j = 0; j < sprite[i].length; j++) {
sprite[i][j] = flippedSprite(new Texture(
- Gdx.files.internal("mobs/" + mob + "/" + i + "_" + j + ".png")));
+ assetLoader.getAssetHandle("mobs/" + mob + "/" + i + "_" + j + ".png")));
sprite[i][j].setOrigin(sprite[i][j].getWidth() / 2, 0);
}
}
* Loads texture names and sizes from <b>json/texture_regions.json</b>, cuts them to TextureRegions
* and puts to {@link #textureRegions} HashMap
*/
- private static void loadJSON() {
- JsonValue json = jsonReader.parse(Gdx.files.internal("json/texture_regions.json"));
+ private static void loadJSON(AssetLoader assetLoader) {
+ JsonValue json = jsonReader.parse(assetLoader.getAssetHandle("json/texture_regions.json"));
for (JsonValue file = json.child(); file != null; file = file.next()) {
- Texture texture = new Texture(Gdx.files.internal(file.name() + ".png"));
+ Texture texture = new Texture(assetLoader.getAssetHandle(file.name() + ".png"));
if (file.size == 0) {
textureRegions.put(file.name(),
flippedRegion(texture, 0, 0, texture.getWidth(), texture.getHeight()));
}
}
- public static void load() {
- loadMob(playerSprite, "char");
- loadMob(pigSprite, "pig");
- loadJSON();
+ public static void load(final AssetLoader assetLoader) {
+ loadMob(assetLoader, playerSprite, "char");
+ loadMob(assetLoader, pigSprite, "pig");
+ loadJSON(assetLoader);
setPlayerHeadOrigin();
- minecraftFont = new BitmapFont(Gdx.files.internal("font.fnt"), true);
+ minecraftFont = new BitmapFont(assetLoader.getAssetHandle("font.fnt"), true);
minecraftFont.getData().setScale(.375f);
}
--- /dev/null
+package ru.deadsoftware.cavedroid.misc.utils
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.files.FileHandle
+import ru.deadsoftware.cavedroid.MainConfig
+import java.io.File
+import javax.inject.Inject
+
+class AssetLoader @Inject constructor(
+ private val mainConfig: MainConfig,
+) {
+
+ fun getAssetHandle(path: String): FileHandle {
+ val texturePackPath =
+ mainConfig.assetsPackPath?.let { if (!it.endsWith(File.separator)) "$it${File.separator}" else it }
+
+ return if (texturePackPath == null) {
+ Gdx.files.internal(path)
+ } else {
+ Gdx.files.absolute("$texturePackPath$path")
+ }
+ }
+
+}
config.useVsync(true);
boolean touch = false;
+ String assetsPath = null;
+
for (String anArg : arg) {
if (anArg.equals("--touch")) {
touch = true;
- break;
}
+
+ if (anArg.startsWith("--assets")) {
+ String[] splitArg = anArg.split("=");
+ if (splitArg.length >= 2) {
+ assetsPath = splitArg[1];
+ }
+ }
}
- new Lwjgl3Application(new CaveGame(System.getProperty("user.home") + "/.cavedroid", touch), config);
+
+ new Lwjgl3Application(
+ new CaveGame(
+ System.getProperty("user.home") + "/.cavedroid",
+ touch,
+ assetsPath),
+ config
+ );
}
}
