From ae0e6ec634d8ab515ae381145a89d9ce649ba082 Mon Sep 17 00:00:00 2001 From: evgenyzinoviev Date: Fri, 14 Aug 2015 17:11:48 +0300 Subject: initial --- src/org/happysanta/gd/Levels/Loader.java | 335 +++++++++++++++++++++++++++++++ 1 file changed, 335 insertions(+) create mode 100755 src/org/happysanta/gd/Levels/Loader.java (limited to 'src/org/happysanta/gd/Levels/Loader.java') diff --git a/src/org/happysanta/gd/Levels/Loader.java b/src/org/happysanta/gd/Levels/Loader.java new file mode 100755 index 0000000..48ef645 --- /dev/null +++ b/src/org/happysanta/gd/Levels/Loader.java @@ -0,0 +1,335 @@ +package org.happysanta.gd.Levels; + +import org.happysanta.gd.GDActivity; +import org.happysanta.gd.Game.GameView; +import org.happysanta.gd.Menu.SimpleMenuElement; +import org.happysanta.gd.Game.Physics; + +import java.io.DataInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; + +import static org.happysanta.gd.Helpers.logDebug; + +public class Loader { + + //public static final int m_bI; + // public static final int m_forI = 1; + // public static final int m_intI = 2; + //public static final int m_doI; + // public static final int m_ifI = 1; + + public File levelsFile; + public Level levels; + public int m_nullI; + public int m_fI; + public String names[][]; + public int m_jI; + public int m_iI; + public int m_longI; + public int m_eI; + public int m_dI; + + private boolean perspectiveEnabled = true; + private boolean shadowsEnabled = true; + private int pointers[][] = new int[3][]; + private int m_eaI = 0; + private int m_faI = 0; + private int m_aI = 0; + private int m_kI = 0; + private int m_saaI[][]; + private int m_haI[]; + private int m_vaI[]; + private int m_daI; + + public Loader() throws IOException { + reset(); + } + + public Loader(File levelsFile) throws IOException { + if (levelsFile != null) + this.levelsFile = levelsFile; + reset(); + } + + private void reset() throws IOException { + m_saaI = null; + levels = null; + m_haI = new int[3]; + m_vaI = new int[3]; + m_nullI = 0; + m_fI = -1; + names = new String[3][]; + m_daI = 0; + for (int j = 0; j < 3; j++) { + m_haI[j] = (int) ((long) (Physics.m_foraI[j] + 19660 >> 1) * (long) (Physics.m_foraI[j] + 19660 >> 1) >> 16); + m_vaI[j] = (int) ((long) (Physics.m_foraI[j] - 19660 >> 1) * (long) (Physics.m_foraI[j] - 19660 >> 1) >> 16); + } + + // try { + readLevels(); + // } catch ( _ex) { + // _ex.printStackTrace(); + //} + _ifvV(); + } + + + public void setLevelsFile(File file) throws IOException { + levelsFile = file; + reset(); + } + + public InputStream getLevelsInputStream(String s) throws IOException { + if (levelsFile == null) + return GDActivity.shared.getAssets().open(s); + else + return new FileInputStream(levelsFile); + } + + private void readLevels() throws IOException { + //try { + InputStream in = getLevelsInputStream("levels.mrg"); + LevelHeader header = Reader.readHeader(in); + + pointers = header.getPointers(); + names = header.getNames(); + //} catch (Exception ex) { + // logDebug("Levels.Loader: error while reading mrg file"); + // ex.printStackTrace(); + //} + } + + public String getLevelName(int j, int k) { + if (j < names.length && k < names[j].length) + return names[j][k]; + else + return "---"; + } + + public void _ifvV() { + try { + _doIII(m_nullI, m_fI + 1); + } catch (InvalidTrackException e) { + e.printStackTrace(); + } + } + + public int _doIII(int j, int k) throws InvalidTrackException { + m_nullI = j; + m_fI = k; + if (m_fI >= names[m_nullI].length) + m_fI = 0; + _hIIV(m_nullI + 1, m_fI + 1); + return m_fI; + } + + private void _hIIV(int j, int k) throws InvalidTrackException { + try { + InputStream is = getLevelsInputStream("levels.mrg"); + DataInputStream dis = new DataInputStream(is); + for (int i1 = pointers[j - 1][k - 1]; i1 > 0; i1 -= dis.skipBytes(i1)) ; + if (levels == null) + levels = new Level(); + levels.readTrackData(dis); + dis.close(); + load(levels); + } catch (IOException _ex) { + _ex.printStackTrace(); + } + } + + public void _ifIV(int j) { + m_jI = levels.startX << 1; + m_iI = levels.startY << 1; + } + + public int _dovI() { + return levels.points[levels.m_forI][0] << 1; + } + + public int _intvI() { + return levels.points[levels.m_gotoI][0] << 1; + } + + public int _newvI() { + return levels.startX << 1; + } + + public int _avI() { + return levels.startY << 1; + } + + public int _aII(int j) { + return levels._doII(j >> 1); + } + + public void load(Level l1) throws InvalidTrackException { + try { + m_longI = 0x80000000; + levels = l1; + int j = levels.pointsCount; + if (m_saaI == null || m_daI < j) { + m_saaI = (int[][]) null; + // System.gc(); + m_daI = j >= 100 ? j : 100; + m_saaI = new int[m_daI][2]; + } + m_eaI = 0; + m_faI = 0; + m_aI = l1.points[m_eaI][0]; + m_kI = l1.points[m_faI][0]; + for (int k = 0; k < j; k++) { + int i1 = l1.points[(k + 1) % j][0] - l1.points[k][0]; + int j1 = l1.points[(k + 1) % j][1] - l1.points[k][1]; + if (k != 0 && k != j - 1) + m_longI = m_longI >= l1.points[k][0] ? m_longI : l1.points[k][0]; + int k1 = -j1; + int i2 = i1; + int j2 = Physics._doIII(k1, i2); + m_saaI[k][0] = (int) (((long) k1 << 32) / (long) j2 >> 16); + m_saaI[k][1] = (int) (((long) i2 << 32) / (long) j2 >> 16); + if (levels.m_gotoI == 0 && l1.points[k][0] > levels.startX) + levels.m_gotoI = k + 1; + if (levels.m_forI == 0 && l1.points[k][0] > levels.finishX) + levels.m_forI = k; + } + + m_eaI = 0; + m_faI = 0; + m_aI = 0; + m_kI = 0; + } catch (ArithmeticException e) { + throw new InvalidTrackException(e); + } + } + + public void _ifIIV(int j, int k) { + levels._ifIIV(j, k); + } + + public void _aiIV(GameView j, int k, int i1) { + if (j != null) { + j.setColor(0, 170, 0); + k >>= 1; + i1 >>= 1; + levels._aiIV(j, k, i1); + } + } + + public void _aiV(GameView j) { + j.setColor(0, 255, 0); + levels._aiV(j); + } + + public void _aIIV(int j, int k, int i1) { + levels._aIIV(j + 0x18000 >> 1, k - 0x18000 >> 1, i1 >> 1); + k >>= 1; + j >>= 1; + m_faI = m_faI >= levels.pointsCount - 1 ? levels.pointsCount - 1 : m_faI; + m_eaI = m_eaI >= 0 ? m_eaI : 0; + if (k > m_kI) + while (m_faI < levels.pointsCount - 1 && k > levels.points[++m_faI][0]) ; + else if (j < m_aI) { + while (m_eaI > 0 && j < levels.points[--m_eaI][0]) ; + } else { + while (m_eaI < levels.pointsCount && j > levels.points[++m_eaI][0]) ; + if (m_eaI > 0) + m_eaI--; + while (m_faI > 0 && k < levels.points[--m_faI][0]) ; + m_faI = m_faI + 1 >= levels.pointsCount - 1 ? levels.pointsCount - 1 : m_faI + 1; + } + m_aI = levels.points[m_eaI][0]; + m_kI = levels.points[m_faI][0]; + } + + public int _anvI(SimpleMenuElement n1, int j) { + int k3 = 0; + byte byte1 = 2; + int l3 = n1.x >> 1; + int i4 = n1.y >> 1; + if (perspectiveEnabled) + i4 -= 0x10000; + int j4 = 0; + int k4 = 0; + for (int l4 = m_eaI; l4 < m_faI; l4++) { + int k = levels.points[l4][0]; + int i1 = levels.points[l4][1]; + int j1 = levels.points[l4 + 1][0]; + int k1; + int _tmp = (k1 = levels.points[l4 + 1][1]) < i1 ? i1 : k1; + if (l3 - m_haI[j] > j1 || l3 + m_haI[j] < k) + continue; + int l1 = k - j1; + int i2 = i1 - k1; + int j2 = (int) ((long) l1 * (long) l1 >> 16) + (int) ((long) i2 * (long) i2 >> 16); + int k2 = (int) ((long) (l3 - k) * (long) (-l1) >> 16) + (int) ((long) (i4 - i1) * (long) (-i2) >> 16); + int l2; + if ((j2 >= 0 ? j2 : -j2) >= 3) + l2 = (int) (((long) k2 << 32) / (long) j2 >> 16); + else + l2 = (k2 <= 0 ? -1 : 1) * (j2 <= 0 ? -1 : 1) * 0x7fffffff; + if (l2 < 0) + l2 = 0; + if (l2 > 0x10000) + l2 = 0x10000; + int i3 = k + (int) ((long) l2 * (long) (-l1) >> 16); + int j3 = i1 + (int) ((long) l2 * (long) (-i2) >> 16); + l1 = l3 - i3; + i2 = i4 - j3; + byte byte0; + long l5; + if ((l5 = ((long) l1 * (long) l1 >> 16) + ((long) i2 * (long) i2 >> 16)) < (long) m_haI[j]) { + if (l5 >= (long) m_vaI[j]) + byte0 = 1; + else + byte0 = 0; + } else { + byte0 = 2; + } + if (byte0 == 0 && (int) ((long) m_saaI[l4][0] * (long) n1.m_eI >> 16) + (int) ((long) m_saaI[l4][1] * (long) n1.m_dI >> 16) < 0) { + m_eI = m_saaI[l4][0]; + m_dI = m_saaI[l4][1]; + return 0; + } + if (byte0 != 1 || (int) ((long) m_saaI[l4][0] * (long) n1.m_eI >> 16) + (int) ((long) m_saaI[l4][1] * (long) n1.m_dI >> 16) >= 0) + continue; + k3++; + byte1 = 1; + if (k3 == 1) { + j4 = m_saaI[l4][0]; + k4 = m_saaI[l4][1]; + } else { + j4 += m_saaI[l4][0]; + k4 += m_saaI[l4][1]; + } + } + + if (byte1 == 1) { + if ((int) ((long) j4 * (long) n1.m_eI >> 16) + (int) ((long) k4 * (long) n1.m_dI >> 16) >= 0) + return 2; + m_eI = j4; + m_dI = k4; + } + return byte1; + } + + public boolean isShadowsEnabled() { + return shadowsEnabled; + } + + public boolean isPerspectiveEnabled() { + return perspectiveEnabled; + } + + public void setPerspectiveEnabled(boolean enabled) { + perspectiveEnabled = enabled; + } + + public void setShadowsEnabled(boolean enabled) { + shadowsEnabled = enabled; + } + +} -- cgit v1.2.3