commit fdd749e12bef19863618c6bfc5f95614611b62a1 Author: PreacherDHM Date: Fri Dec 13 00:04:15 2024 +0000 first diff --git a/Sorce/.gitignore b/Sorce/.gitignore new file mode 100755 index 0000000..aa724b7 --- /dev/null +++ b/Sorce/.gitignore @@ -0,0 +1,15 @@ +*.iml +.gradle +/local.properties +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx +local.properties diff --git a/Sorce/.idea/.gitignore b/Sorce/.idea/.gitignore new file mode 100755 index 0000000..eaf91e2 --- /dev/null +++ b/Sorce/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/Sorce/.idea/.name b/Sorce/.idea/.name new file mode 100755 index 0000000..863899b --- /dev/null +++ b/Sorce/.idea/.name @@ -0,0 +1 @@ +AlphaUnit \ No newline at end of file diff --git a/Sorce/.idea/compiler.xml b/Sorce/.idea/compiler.xml new file mode 100755 index 0000000..8fabff5 --- /dev/null +++ b/Sorce/.idea/compiler.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Sorce/.idea/gradle.xml b/Sorce/.idea/gradle.xml new file mode 100755 index 0000000..02a60b0 --- /dev/null +++ b/Sorce/.idea/gradle.xml @@ -0,0 +1,20 @@ + + + + + + + \ No newline at end of file diff --git a/Sorce/.idea/misc.xml b/Sorce/.idea/misc.xml new file mode 100755 index 0000000..8978d23 --- /dev/null +++ b/Sorce/.idea/misc.xml @@ -0,0 +1,9 @@ + + + + + + + + \ No newline at end of file diff --git a/Sorce/app/.gitignore b/Sorce/app/.gitignore new file mode 100755 index 0000000..42afabf --- /dev/null +++ b/Sorce/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/Sorce/app/build.gradle b/Sorce/app/build.gradle new file mode 100755 index 0000000..32eb0ca --- /dev/null +++ b/Sorce/app/build.gradle @@ -0,0 +1,43 @@ +plugins { + id 'com.android.application' +} + +android { + namespace 'com.main.alphaunit' + compileSdk 33 + + defaultConfig { + applicationId "com.main.alphaunit" + minSdk 33 + targetSdk 33 + versionCode 1 + versionName "1.0" + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + } + + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } +} + +dependencies { + implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.2.0-alpha01" + implementation 'androidx.appcompat:appcompat:1.6.1' + implementation 'com.google.android.material:material:1.9.0' + implementation 'androidx.constraintlayout:constraintlayout:2.1.4' + testImplementation 'junit:junit:4.13.2' + androidTestImplementation 'androidx.test.ext:junit:1.1.5' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1' + implementation 'com.squareup.retrofit2:retrofit:2.7.2' + implementation 'com.squareup.retrofit2:converter-gson:2.7.2' + implementation("io.coil-kt:coil:2.4.0") + implementation("com.squareup.okhttp3:okhttp:4.8.0") +} \ No newline at end of file diff --git a/Sorce/app/proguard-rules.pro b/Sorce/app/proguard-rules.pro new file mode 100755 index 0000000..481bb43 --- /dev/null +++ b/Sorce/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/Sorce/app/src/androidTest/java/com/main/alphaunit/ExampleInstrumentedTest.java b/Sorce/app/src/androidTest/java/com/main/alphaunit/ExampleInstrumentedTest.java new file mode 100755 index 0000000..f95f73d --- /dev/null +++ b/Sorce/app/src/androidTest/java/com/main/alphaunit/ExampleInstrumentedTest.java @@ -0,0 +1,26 @@ +package com.main.alphaunit; + +import android.content.Context; + +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Test; +import org.junit.runner.RunWith; + +import static org.junit.Assert.*; + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class ExampleInstrumentedTest { + @Test + public void useAppContext() { + // Context of the app under test. + Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); + assertEquals("com.main.alphaunit", appContext.getPackageName()); + } +} \ No newline at end of file diff --git a/Sorce/app/src/main/AndroidManifest.xml b/Sorce/app/src/main/AndroidManifest.xml new file mode 100755 index 0000000..d15973e --- /dev/null +++ b/Sorce/app/src/main/AndroidManifest.xml @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Sorce/app/src/main/java/com/main/alphaunit/MainActivity.java b/Sorce/app/src/main/java/com/main/alphaunit/MainActivity.java new file mode 100755 index 0000000..d95cd87 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/MainActivity.java @@ -0,0 +1,476 @@ +package com.main.alphaunit; + +import androidx.annotation.NonNull; +import androidx.appcompat.app.AppCompatActivity; +import androidx.appcompat.widget.SearchView; +import androidx.appcompat.widget.SearchView.OnQueryTextListener; +import androidx.cardview.widget.CardView; +import androidx.constraintlayout.widget.ConstraintLayout; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; +import androidx.swiperefreshlayout.widget.SwipeRefreshLayout; + + +import android.animation.Animator; +import android.animation.TimeInterpolator; +import android.animation.ValueAnimator; +import android.app.ActionBar; +import android.content.Context; +import android.content.Intent; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.hardware.input.InputManager; +import android.net.Uri; +import android.os.AsyncTask; +import android.os.Bundle; +import android.os.CombinedVibration; +import android.os.VibrationAttributes; +import android.os.VibrationEffect; +import android.os.Vibrator; +import android.os.VibratorManager; +import android.util.DisplayMetrics; +import android.util.Log; +import android.util.TypedValue; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.SearchEvent; +import android.view.View; +import android.view.ViewGroup; +import android.view.Window; +import android.view.WindowManager; +import android.view.animation.AccelerateInterpolator; +import android.view.animation.AlphaAnimation; +import android.view.animation.Animation; +import android.view.animation.AnimationUtils; +import android.view.animation.DecelerateInterpolator; +import android.view.animation.ScaleAnimation; +import android.view.inputmethod.EditorInfo; +import android.view.inputmethod.InputMethodManager; +import android.webkit.WebView; +import android.widget.Button; +import android.widget.EditText; +import android.widget.FrameLayout; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.RelativeLayout; +import android.widget.TextView; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.main.alphaunit.UIComponents.UnitCardAnim; +import com.main.alphaunit.bul.MULApi; +import com.main.alphaunit.bul.MULClient; +import com.main.alphaunit.bul.Unit; +import com.main.alphaunit.bul.UnitLists; +import com.main.alphaunit.bul.UnitListsManager; +import com.main.alphaunit.bul.UnitOnUITouch; +import com.main.alphaunit.bul.Unit_RecyclerViewAdapter; +import com.main.alphaunit.bul.UserMasterUnitSelection; + +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URL; +import java.nio.channels.SelectionKey; +import java.util.ArrayList; + +import coil.ImageLoader; +import coil.request.ImageRequest; +import okhttp3.ResponseBody; +import retrofit2.Call; +import retrofit2.Callback; +import retrofit2.Response; + +public class MainActivity extends AppCompatActivity { + private TextView tv; + private TextView pointValue; + private TextView tonnage; + private LinearLayout ll; + private RecyclerView recyclerView; + private SwipeRefreshLayout srl; + private EditText Search; + private Context con; + private Unit_RecyclerViewAdapter adapter; + private ImageView image; + private VibratorManager vm; + private Vibrator v; + private LinearLayout BottomMenu; + private Button SlideMenu; + private RelativeLayout unitSRLContainer; + private FrameLayout side_menu_container; + private WebView mechWikiView; + int imageResetHight; + int currentHight; + private boolean sideMenuOpen = true; + private boolean donewithdata = false; + private boolean isSavedUnitsSelected = false; + + boolean isImageLarge = false; + ArrayList units = new ArrayList<>(); + ArrayList SelectedUnits = new ArrayList<>(); + UnitLists selectedUnitList; + ArrayList unitLists = new ArrayList<>(); + int unitListsID = 0; + + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_main); + tv = findViewById(R.id.Data); + recyclerView = findViewById(R.id.RUnitView); + srl = findViewById(R.id.unitsrl); + Search = findViewById(R.id.UnitSearch); + image = findViewById(R.id.UnitImageView); + BottomMenu = findViewById(R.id.BottomMenu); + unitSRLContainer = findViewById(R.id.unitsrlContiner); + SlideMenu = findViewById(R.id.SlideMenu); + mechWikiView = findViewById(R.id.mechWiki_View); + pointValue = findViewById(R.id.Point_Value_TV); + tonnage = findViewById(R.id.Tonnage_TV); + //side_menu_container = findViewById(R.id.side_menue_container); + con = this; + + UnitListsManager.loadUnitLists(con); + unitLists = UnitListsManager.unitsLists; + UnitListsManager.unitsLists.size(); + if(UnitListsManager.unitsLists != null) { + for (UnitLists list : + UnitListsManager.unitsLists) { + unitListsID ++; + if (list.isSelected()) { + selectedUnitList = list; + if(selectedUnitList.getUnits()!= null) { + SelectedUnits = selectedUnitList.getUnits(); + units = SelectedUnits; + adapter = new Unit_RecyclerViewAdapter(con,SelectedUnits); + recyclerView.setAdapter(adapter); + recyclerView.setLayoutManager(new LinearLayoutManager(con)); + //tv.setText("GOOD "+units.size()); + srl.setRefreshing(false); + isSavedUnitsSelected = true; + tv.setText("Not NULL!! " + list.getName()); + }else { + tv.setText("NULL!!"); + } + break; + } + tv.append(""+unitListsID); + + } + } + + pointValue.setText(selectedUnitList.getPointCount()+"PV"); + tonnage.setText("Tonnage"); + + currentHight = (int)TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 175f, getResources().getDisplayMetrics()); + imageResetHight = getResources().getDisplayMetrics().heightPixels; + + float BottomViewResetPosition = recyclerView.getY(); + + ViewGroup.LayoutParams bottomMenuLayoutParams = BottomMenu.getLayoutParams(); + + BottomMenu.setMinimumHeight(currentHight); + UnitCardAnim anim = new UnitCardAnim(); + + image.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + tv.setText("getY: " + BottomMenu.getY()); + if(!isImageLarge) { + //BottomMenu.setLayoutParams(recyclerView.getLayoutParams()); + anim.imageFullScreen(UnitCardAnim.UnitCardState.fullScreen,BottomMenu,recyclerView); + isImageLarge = true; + } else if(isImageLarge) { + //BottomMenu.setLayoutParams(bottomMenuLayoutParams); + anim.imageFullScreen(UnitCardAnim.UnitCardState.bottomScreen,BottomMenu,recyclerView); + isImageLarge = false; + } + + } + }); + + + vm = (VibratorManager) getSystemService(Context.VIBRATOR_MANAGER_SERVICE); + v = vm.getDefaultVibrator(); + + SlideMenu.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + + //SelectedUnits = UnitListsManager.getSelectedUnitList().getUnits(); + //UnitListsManager.getSelectedUnitList().setUnits(SelectedUnits); + //UserMasterUnitSelection.loadMasterSelection(con); + //units = UnitListsManager.getSelectedUnitList().getUnits(); + + if(selectedUnitList.getUnits() == null) { + selectedUnitList.setUnits(SelectedUnits); + }else { + selectedUnitList.setUnits(SelectedUnits); + SelectedUnits = (selectedUnitList.getUnits()); + } + + + units = SelectedUnits; + adapter = new Unit_RecyclerViewAdapter(con,SelectedUnits); + recyclerView.setAdapter(adapter); + recyclerView.setLayoutManager(new LinearLayoutManager(con)); + //tv.setText("GOOD "+units.size()); + srl.setRefreshing(false); + isSavedUnitsSelected = true; + } + }); + + SlideMenu.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View view) { + UnitListsManager.unitsLists = unitLists; + UnitListsManager.saveUnitLists(con); + Intent i = new Intent(con, UnitListsSelection.class); + startActivity(i); + return true; + } + }); + + // This is click event for the recyclerview (the thing that has all the unitsUI stff) + recyclerView.addOnItemTouchListener(new UnitOnUITouch(this, recyclerView, new UnitOnUITouch.OnItemClickListener() { + @Override + public void onItemClick(View view, int position) { + tv.setText("tuch: "+ position); + MULClient.getUnitImage(image, units.get(position).id, 4, new MULClient.ImageViewLoad() { + @Override + public void onLoad(Response response, Bitmap bitmap) { + v.vibrate(VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)); + anim.setState(UnitCardAnim.UnitCardState.Up); + anim.cardInAndOutOfView(recyclerView,BottomMenu,image,imageResetHight); + anim.getCurrentAnim().addListener(new Animator.AnimatorListener() { + @Override + public void onAnimationStart(@NonNull Animator animator) {} + @Override + public void onAnimationEnd(@NonNull Animator animator) { + image.setImageBitmap(bitmap); + anim.loadUnitWiki(mechWikiView, units.get(position).mechClass); + anim.cardInAndOutOfView(recyclerView,BottomMenu,image,imageResetHight); + } + @Override + public void onAnimationCancel(@NonNull Animator animator) {} + @Override + public void onAnimationRepeat(@NonNull Animator animator) {} + }); + } + @Override + public void onFail(Throwable throwable) { + + v.vibrate(VibrationEffect.createWaveform(new long[] {150,150,40},new int[] {120,00,100},-1)); + anim.setState(UnitCardAnim.UnitCardState.Down); + anim.cardInAndOutOfView(recyclerView,BottomMenu,image, imageResetHight); + } + }); + CardView cv = view.findViewById(R.id.MyCard); + Animation animation = AnimationUtils.loadAnimation(getApplicationContext(),R.anim.blink); + cv.startAnimation(animation); + } + + @Override + public void onLongItemClick(View view, int position) { + tv.setText("Long tuch: " + position); + if(!isSavedUnitsSelected) { + + SelectedUnits.add(units.get(position)); + v.vibrate(VibrationEffect.createPredefined(VibrationEffect.EFFECT_DOUBLE_CLICK)); + CardView cv = view.findViewById(R.id.MyCard); + Animation animation = AnimationUtils.loadAnimation(getApplicationContext(), R.anim.blink); + cv.startAnimation(animation); + } else { + SelectedUnits.remove(position); + units = SelectedUnits; + v.vibrate(VibrationEffect.createPredefined(VibrationEffect.EFFECT_DOUBLE_CLICK)); + CardView cv = view.findViewById(R.id.MyCard); + Animation animation = AnimationUtils.loadAnimation(getApplicationContext(), R.anim.blink); + cv.startAnimation(animation); + adapter = new Unit_RecyclerViewAdapter(con,SelectedUnits); + recyclerView.setAdapter(adapter); + recyclerView.setLayoutManager(new LinearLayoutManager(con)); + } + + pointValue.setText(selectedUnitList.getPointCount()+"PV"); + tonnage.setText("Tonnage"); + UnitListsManager.unitsLists = unitLists; + UnitListsManager.saveUnitLists(con); + + + } + })); + + + Search.setOnEditorActionListener(new TextView.OnEditorActionListener() { + @Override + public boolean onEditorAction(TextView textView, int i, KeyEvent keyEvent) { + if(i == EditorInfo.IME_ACTION_SEARCH && Search.getText().length() > 2) { + Search.clearFocus(); + InputMethodManager in = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); + in.hideSoftInputFromWindow(Search.getWindowToken(),0); + srl.setRefreshing(true); + + isSavedUnitsSelected = false; + getData(Search.getText().toString()); + }else { + + Search.clearFocus(); + InputMethodManager in = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); + in.hideSoftInputFromWindow(Search.getWindowToken(),0); + srl.setRefreshing(false); + + } + return false; + } + }); + + + srl.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() { + @Override + public void onRefresh() { + + isSavedUnitsSelected = false; + srl.setRefreshing(true); + //getData(Search.getText().toString()); + SelectedUnits = selectedUnitList.getUnits(); + units = SelectedUnits; + adapter = new Unit_RecyclerViewAdapter(con,SelectedUnits); + recyclerView.setAdapter(adapter); + recyclerView.setLayoutManager(new LinearLayoutManager(con)); + //tv.setText("GOOD "+units.size()); + srl.setRefreshing(false); + isSavedUnitsSelected = true; + } + }); + + } + + private void Dommy() { + Unit unit = new Unit(); + for (int i = 0; i < 10; i++) { + units.add(new Unit()); + } + } + + + //Gets the image for the units + private void getImage(int id, int skill) { + Call call = MULClient.getInstance().getMULApi().getMechImage(Integer.toString(id), skill); + //byte[] bytes; + + call.enqueue(new Callback() { + @Override + public void onResponse(Call call, Response response) { + image.setImageBitmap(BitmapFactory.decodeStream(response.body().byteStream())); + ValueAnimator UnitRecycalViewScaileDownAnim = ValueAnimator.ofInt(0,700); + UnitRecycalViewScaileDownAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + recyclerView.setPadding(0,0,0,(Integer) valueAnimator.getAnimatedValue()); + } + }); + UnitRecycalViewScaileDownAnim.setInterpolator(new DecelerateInterpolator(2)); + UnitRecycalViewScaileDownAnim.start(); + + BottomMenu.setAlpha(1.0f); + + ValueAnimator BottomViewUpAnim = ValueAnimator.ofFloat(imageResetHight,imageResetHight-700); + BottomViewUpAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + BottomMenu.setY((Float) valueAnimator.getAnimatedValue()); + } + }); + BottomViewUpAnim.setInterpolator(new DecelerateInterpolator(2)); + BottomViewUpAnim.start(); + + } + + @Override + public void onFailure(Call call, Throwable t) { + //tv.setText("Image did not work"); + //v.vibrate(VibrationEffect.createWaveform(new long[] {150,150,40},new int[] {120,00,100},-1)); + + //BottomMenu.setAlpha(0.0f); + } + }); + tv.setText("Done"); + } + + private void getData(String Search) { + Call call = MULClient.getInstance().getMULApi().getMechs(Search); + + call.enqueue(new Callback() { + @Override + public void onResponse(Call call, Response response) { + JsonObject jo = response.body(); + JsonArray UnitList; + + if(!jo.get("Units").isJsonNull()) { + units = new ArrayList(); + UnitList = jo.get("Units").getAsJsonArray(); + Unit tmp = new Unit(); + for (int i = 0; i < jo.get("Units").getAsJsonArray().size(); i++) { + units.add(new Unit()); + //units.get(0).mechClass = response.body().getAsJsonObject().get("Unit").getAsString(); + if (!UnitList.get(i).getAsJsonObject().get("Id").isJsonNull()) + units.get(i).id = UnitList.get(i).getAsJsonObject().get("Id").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFArmor").isJsonNull()) + units.get(i).armor= UnitList.get(i).getAsJsonObject().get("BFArmor").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFStructure").isJsonNull()) + units.get(i).structure = UnitList.get(i).getAsJsonObject().get("BFStructure").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFOverheat").isJsonNull()) + units.get(i).overheat = UnitList.get(i).getAsJsonObject().get("BFOverheat").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFDamageShort").isJsonNull()) + units.get(i).damageShort = UnitList.get(i).getAsJsonObject().get("BFDamageShort").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFDamageMedium").isJsonNull()) + units.get(i).damageMedium = UnitList.get(i).getAsJsonObject().get("BFDamageMedium").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFDamageLong").isJsonNull()) + units.get(i).damageLong = UnitList.get(i).getAsJsonObject().get("BFDamageLong").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFDamageExtreme").isJsonNull()) + units.get(i).damageExtreme = UnitList.get(i).getAsJsonObject().get("BFDamageExtreme").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFPointValue").isJsonNull()) + units.get(i).baseBP = UnitList.get(i).getAsJsonObject().get("BFPointValue").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("Tonnage").isJsonNull()) + units.get(i).tonnage = UnitList.get(i).getAsJsonObject().get("Tonnage").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("BFTMM").isJsonNull()) + units.get(i).tmm = UnitList.get(i).getAsJsonObject().get("BFTMM").getAsInt(); + if (!UnitList.get(i).getAsJsonObject().get("Class").isJsonNull()) + units.get(i).mechClass = UnitList.get(i).getAsJsonObject().get("Class").getAsString(); + if (!UnitList.get(i).getAsJsonObject().get("Variant").isJsonNull()) + units.get(i).mechVariant = UnitList.get(i).getAsJsonObject().get("Variant").toString(); + if(!UnitList.get(i).getAsJsonObject().get("Role").getAsJsonObject().get("Name").isJsonNull()) + units.get(i).role = UnitList.get(i).getAsJsonObject().get("Role").getAsJsonObject().get("Name").getAsString(); + if(!UnitList.get(i).getAsJsonObject().get("Technology").getAsJsonObject().get("Name").isJsonNull()) + units.get(i).technology = UnitList.get(i).getAsJsonObject().get("Technology").getAsJsonObject().get("Name").getAsString(); + units.get(i).movement = UnitList.get(i).getAsJsonObject().get("BFMove").getAsString(); + if (!UnitList.get(i).getAsJsonObject().get("BFAbilities").isJsonNull()) + units.get(i).Abilities = UnitList.get(i).getAsJsonObject().get("BFAbilities").getAsString(); + + } + donewithdata = true; + + adapter = new Unit_RecyclerViewAdapter(con,units); + recyclerView.setAdapter(adapter); + recyclerView.setLayoutManager(new LinearLayoutManager(con)); + tv.setText("GOOD "+units.size()); + srl.setRefreshing(false); + } else { + + tv.setText("NOT GOOD"); + srl.setRefreshing(false); + } + donewithdata = true; + } + + @Override + public void onFailure(Call call, Throwable t) { + tv.setText("This was not working\n" + t.toString()); + + donewithdata = true; + } + }); + + } +} \ No newline at end of file diff --git a/Sorce/app/src/main/java/com/main/alphaunit/PilotCreation.java b/Sorce/app/src/main/java/com/main/alphaunit/PilotCreation.java new file mode 100644 index 0000000..161f0c4 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/PilotCreation.java @@ -0,0 +1,14 @@ +package com.main.alphaunit; + +import androidx.appcompat.app.AppCompatActivity; + +import android.os.Bundle; + +public class PilotCreation extends AppCompatActivity { + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_pilot_creation); + } +} \ No newline at end of file diff --git a/Sorce/app/src/main/java/com/main/alphaunit/UIComponents/UnitCardAnim.java b/Sorce/app/src/main/java/com/main/alphaunit/UIComponents/UnitCardAnim.java new file mode 100755 index 0000000..d8de606 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/UIComponents/UnitCardAnim.java @@ -0,0 +1,210 @@ +package com.main.alphaunit.UIComponents; + +import android.animation.Animator; +import android.animation.ValueAnimator; +import android.net.Uri; +import android.view.View; +import android.view.animation.AccelerateInterpolator; +import android.view.animation.Animation; +import android.view.animation.DecelerateInterpolator; +import android.view.animation.LinearInterpolator; +import android.webkit.WebSettings; +import android.webkit.WebView; +import android.webkit.WebViewClient; + +import androidx.annotation.NonNull; +import androidx.recyclerview.widget.RecyclerView; + +public class UnitCardAnim { + + private UnitCardState currentState; + private boolean swipe = false; + private boolean swipeOut = true; + private boolean swipeIn = false; + private boolean isUp = false; + + private Animator currentAnim; + public enum UnitCardState { + Up, + Down, + fullScreen, + bottomScreen, + } + + public UnitCardState getState() {return currentState;} + public Animator getCurrentAnim() {return currentAnim;} + + public void loadUnitWiki(WebView webview, String mechClass){ + webview.setWebViewClient(new WebViewClient() { + @SuppressWarnings("deprecation") + @Override + public boolean shouldOverrideUrlLoading(WebView view, String url) { + view.loadUrl(url); + return false; + } + }); + webview.loadUrl("https://www.sarna.net/wiki/"+mechClass); + } + + // Swipe image left and right + private void swipeImage(View image) { + + if(swipeOut) { + swipeOut = false; + ValueAnimator SwipeLeft = ValueAnimator.ofFloat(0, -1000); + SwipeLeft.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + image.setTranslationX((Float) valueAnimator.getAnimatedValue()); + } + }); + SwipeLeft.setInterpolator(new AccelerateInterpolator(5f)); + SwipeLeft.setDuration(200); + SwipeLeft.start(); + swipeIn = true; + currentAnim = SwipeLeft; + } + else if(swipeIn) { + swipeIn = false; + ValueAnimator SwipeRight = ValueAnimator.ofFloat(-1000, 0); + SwipeRight.setStartDelay(300); + SwipeRight.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + image.setTranslationX((Float) valueAnimator.getAnimatedValue()); + } + }); + SwipeRight.setInterpolator(new DecelerateInterpolator(5f)); + SwipeRight.setDuration(200); + SwipeRight.start(); + swipeOut = true; + currentAnim = SwipeRight; + } + } + public void setState(UnitCardState state) { if(currentState == UnitCardState.Up && state == currentState) { swipe = true;} currentState = state;} + public void cardInAndOutOfView(RecyclerView rv, View card, View image, int startingPosition) { + + // If the card is down and is out of screen bring it up + if(currentState == UnitCardState.Up && !swipe && !isUp) { + + ValueAnimator UnitRecycalViewScaileDownAnim = ValueAnimator.ofInt(0, 850); + UnitRecycalViewScaileDownAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + rv.setTranslationY(-(Integer) valueAnimator.getAnimatedValue()); + rv.setPadding(0, (Integer) valueAnimator.getAnimatedValue(),0,0); + } + }); + UnitRecycalViewScaileDownAnim.setInterpolator(new DecelerateInterpolator(2)); + UnitRecycalViewScaileDownAnim.start(); + + card.setAlpha(1.0f); + + ValueAnimator BottomViewUpAnim = ValueAnimator.ofFloat(startingPosition,startingPosition -850); + BottomViewUpAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + card.setY((Float) valueAnimator.getAnimatedValue()); + } + }); + BottomViewUpAnim.setInterpolator(new DecelerateInterpolator(2)); + BottomViewUpAnim.start(); + + currentAnim = BottomViewUpAnim; + isUp = true; + + } + // If The card is in view bring it down + else if (currentState == UnitCardState.Down && isUp) { + ValueAnimator UnitRecycalViewScaileDownAnim = ValueAnimator.ofInt(850, 0); + UnitRecycalViewScaileDownAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + rv.setTranslationY( -(Integer) valueAnimator.getAnimatedValue()); + rv.setPadding(0, (Integer) valueAnimator.getAnimatedValue(),0,0); + } + }); + UnitRecycalViewScaileDownAnim.setInterpolator(new AccelerateInterpolator(2f)); + UnitRecycalViewScaileDownAnim.start(); + + card.setAlpha(1.0f); + + ValueAnimator BottomViewUpAnim = ValueAnimator.ofFloat(startingPosition-850, startingPosition+500); + BottomViewUpAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + card.setY((Float) valueAnimator.getAnimatedValue()); + } + }); + BottomViewUpAnim.setInterpolator(new AccelerateInterpolator(2f)); + BottomViewUpAnim.start(); + currentAnim = BottomViewUpAnim; + isUp = false; + swipe = false; + } + // if the card is up move the image back and forth + else if(currentState == UnitCardState.Up && swipe && isUp) { + + swipeImage(image); + } + } + + public void imageFullScreen(UnitCardState state,View imageContainer, RecyclerView recycalView) { + + if(state == UnitCardState.fullScreen) { + float firstPosition = recycalView.getY(); + ValueAnimator recycalViewShrink = ValueAnimator.ofInt(850, 2500); + ValueAnimator imageContainerMoveUp = ValueAnimator.ofInt(850, 2500); + recycalViewShrink.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + imageContainer.setPadding(-10,-10,-10,-10); + recycalView.setTranslationY(-(Integer) valueAnimator.getAnimatedValue()); + recycalView.setPadding(0, (Integer) valueAnimator.getAnimatedValue(), 0, 0); + } + }); + recycalViewShrink.setDuration(500); + recycalViewShrink.setInterpolator(new AccelerateInterpolator(2)); + + imageContainerMoveUp.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + imageContainer.setTranslationY(-(Integer) valueAnimator.getAnimatedValue()); + } + }); + imageContainerMoveUp.setInterpolator(new AccelerateInterpolator(2)); + imageContainerMoveUp.setDuration(500); + + + + imageContainerMoveUp.start(); + recycalViewShrink.start(); + + } else if(state == UnitCardState.bottomScreen){ + + float firstPosition = recycalView.getY(); + ValueAnimator recycalViewShrink = ValueAnimator.ofInt(2500,850 ); + ValueAnimator imageContainerMoveUp = ValueAnimator.ofInt(2500, 850); + recycalViewShrink.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + recycalView.setTranslationY(-(Integer) valueAnimator.getAnimatedValue()); + recycalView.setPadding(0, (Integer) valueAnimator.getAnimatedValue(), 0, 0); + } + }); + recycalViewShrink.setDuration(500); + recycalViewShrink.setInterpolator(new AccelerateInterpolator(2)); + + imageContainerMoveUp.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { + @Override + public void onAnimationUpdate(@NonNull ValueAnimator valueAnimator) { + imageContainer.setTranslationY(-(Integer) valueAnimator.getAnimatedValue()); + } + }); + imageContainerMoveUp.setInterpolator(new AccelerateInterpolator(2)); + imageContainerMoveUp.setDuration(500); + imageContainerMoveUp.start(); + recycalViewShrink.start(); + } + } +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/UnitListsSelection.java b/Sorce/app/src/main/java/com/main/alphaunit/UnitListsSelection.java new file mode 100755 index 0000000..ebcc735 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/UnitListsSelection.java @@ -0,0 +1,119 @@ +package com.main.alphaunit; + +import androidx.appcompat.app.AppCompatActivity; +import androidx.recyclerview.widget.LinearLayoutManager; +import androidx.recyclerview.widget.RecyclerView; + +import android.content.Context; +import android.content.Intent; +import android.os.Bundle; +import android.view.View; +import android.view.animation.Animation; +import android.view.animation.AnimationUtils; +import android.widget.Button; +import android.widget.EditText; +import android.widget.TextView; + +import com.main.alphaunit.bul.UnitLists; +import com.main.alphaunit.bul.UnitListsManager; +import com.main.alphaunit.bul.UnitLists_RecyclerViewAdapter; +import com.main.alphaunit.bul.UnitOnUITouch; + +import java.util.ArrayList; + +public class UnitListsSelection extends AppCompatActivity { + + private RecyclerView unitListsRecyclerView; + private UnitLists_RecyclerViewAdapter adapter; + + private EditText listNameIn; + private EditText listDescriptionIn; + private TextView dbugView; + + private Button backToMainActivity; + private Button addUnitList; + + UnitLists selectedUnitList; + private ArrayList unitLists; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_unit_lists_selection); + Context con = this; + + unitListsRecyclerView = findViewById(R.id.UnitListRecyclerView); + backToMainActivity = findViewById(R.id.BackToMainActivity); + addUnitList = findViewById(R.id.AddUnitList); + listNameIn = findViewById(R.id.unitListNameIn); + listDescriptionIn = findViewById(R.id.UnitDescriptionIn); + dbugView = findViewById(R.id.dbug); + unitLists = new ArrayList<>(); + + + UnitListsManager.loadUnitLists(con); + UnitListsManager.unitsLists.size(); + unitLists = UnitListsManager.unitsLists; + adapter = new UnitLists_RecyclerViewAdapter(con, unitLists); + unitListsRecyclerView.setAdapter(new UnitLists_RecyclerViewAdapter(con,unitLists)); + unitListsRecyclerView.setLayoutManager(new LinearLayoutManager(con)); + + + for (int i = 0; i < unitLists.size(); i++) { + if(unitLists.get(i).isSelected()){ + selectedUnitList = unitLists.get(i); + dbugView.setText(""+ unitLists.get(i).getName()); + break; + } + } + + unitListsRecyclerView.addOnItemTouchListener(new UnitOnUITouch(this, unitListsRecyclerView, new UnitOnUITouch.OnItemClickListener() { + @Override + public void onItemClick(View view, int position) { + if(selectedUnitList != null) { + selectedUnitList.deselect(); + } + selectedUnitList = unitLists.get(position); + selectedUnitList.select(); + Animation animation = AnimationUtils.loadAnimation(getApplicationContext(),R.anim.blink); + view.findViewById(R.id.UnitListName).startAnimation(animation); + UnitListsManager.saveUnitLists(con); + Intent i = new Intent(con, MainActivity.class); + startActivity(i); + } + + @Override + public void onLongItemClick(View view, int position) { + unitLists.remove(position); + UnitListsManager.unitsLists = unitLists; + UnitListsManager.saveUnitLists(con); + adapter = new UnitLists_RecyclerViewAdapter(con, unitLists); + unitListsRecyclerView.setAdapter(new UnitLists_RecyclerViewAdapter(con,unitLists)); + unitListsRecyclerView.setLayoutManager(new LinearLayoutManager(con)); + } + })); + + addUnitList.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + unitLists.add(new UnitLists(listNameIn.getText().toString(), listDescriptionIn.getText().toString())); + UnitListsManager.unitsLists = unitLists; + UnitListsManager.saveUnitLists(con); + adapter = new UnitLists_RecyclerViewAdapter(con, unitLists); + unitListsRecyclerView.setAdapter(new UnitLists_RecyclerViewAdapter(con,unitLists)); + unitListsRecyclerView.setLayoutManager(new LinearLayoutManager(con)); + UnitListsManager.unitsLists = unitLists; + UnitListsManager.saveUnitLists(con); + } + }); + + backToMainActivity.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View view) { + UnitListsManager.saveUnitLists(con); + Intent i = new Intent(con, MainActivity.class); + startActivity(i); + } + }); + } +} \ No newline at end of file diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/AbilityIndex.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/AbilityIndex.java new file mode 100644 index 0000000..b996b6b --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/AbilityIndex.java @@ -0,0 +1,48 @@ +package com.main.alphaunit.bul; + +import java.util.ArrayList; + +public class AbilityIndex { + public class Ability{ + String name; + String definition; + + public Ability(String abilityName, String abilityDefinition) { + name = abilityName; + definition = abilityDefinition; + setIndex(); + } + + public String getDefinition() { + return definition; + } + public String getName() { + return name; + } + + } + + String unitAbilities; + ArrayList index = new ArrayList<>(); + private void setIndex() { + index.clear(); + index.add(new Ability("ADVANCED FIRE CONTROL:AFC","Industrial-Mechs and support vehicles equipped with Advanced Fire Control do not suffer Target Number modifiers for their unit type.")); + index.add(new Ability("AMPHIBIOUS:AMP","THis ability makes a non-naval unit capable of water movement. Amphibious units play a total of 4'' per inch of water traversed and move as a surface naval unit in water, except that they freely move in and out of water areas.")); + index.add(new Ability("ANGEL ECM:AECM", "An angel ECM suite has the effects of standard ECM (see p.77) but is treated two standard ECM suites if using the ECM/ECCM optional rule (see p. 161).")); + index.add(new Ability("ANTI-MECH:AM", "Infantry units with the Anti-Mech (AM) special ability can make a special attack against any ground units, landed VTOLs and WiGEs, or grounded aerospace units with which they are in base-to-base contact. Anti-Mech Infantry attacks are treated as a physical attack (see p. 45).")); + index.add(new Ability("ANTI-MISSILE SYSTEM:AMS", "A unit with an AMS reduces the damage by 1 point (to a minimum of 1) from any of the following attacks: standard weapon attack from a unit with the IF, SRM, or LRM special abilities, Indirect Fire attack uning the IF special ability, or special weapon attack make using the SRM or LRM special abilties, AMS only works on attacks coming in the front arc, unless mounted in a turret (TUR).")); + index.add(new Ability("ARMORED COMPONENTS:ARM", "A unit with this ability ignores the first critical hit chance rolled against it during a single Alpha Strike scenario. The first time circumstances arise that would normally generate on opportunity for a critical hit (such as structure damage), the unit's controlling player must strike off this ability as 'spent' for the remainder of the scenario, and the attacker loses his first opportunity to roll for a critical hit")); + index.add(new Ability("ARMORED MOTIVE SYSTEMS:ARS", "A unit with this special ability applies a -1 modifier on the Determining Motive Systems Damage roll (see Motive Systems Damage Table, p. 50).")); + index.add(new Ability("BARRIER ARMOR RATING:BAR", "The BAR special indicates a unit that is protected by substandard armor (or commerialpgrade armor). Successful attacks against such units always trigger a roll for critical hits, regardless of whether or not the structure is damaged.")); + index.add(new Ability("BASIC FIRE CONTOL:BFC", "A support vehicle or IndustrialMech with this ability has an inferior targeting and tracking system, which adds a Target Number modifier of +1 for its attack. (This modifier is listed in the Attack Modifiers Table, see p. 44.)")); + index.add(new Ability("BATTLEMECH HARJEL:BHJ","a Mech protected by HarJel ignores the additional 'hull breach' critical hit checks required for being attacked while underwater or in a vacuum. All other causes for critical hit rolls still apply as normal.")); + index.add(new Ability("BATTLEMECH SHIELD:SHLD", "Shield-bearing Mechs gain some protection against weapon and physical attacks at the expense of their own attack accuracy. To reflect this, shield-equipped units reduce the damage from most weapons and physical attacks by 1 point (to a minimum of 0). Indirect attacks, heat-causing attacks, and area-effect attacks (such as artillery and bombs) are not dampened by the shield and thus deliver full damage. All weapon attacks made by a Mech with this ability incur an additional +1 Target Number modifier.")); + index.add(new Ability("BOMB:BOMB#", "Conventional and aerospace fighters, fixed-wing support vehicles, and some battle armor can carry bombs. The number of Bombs these units can carr are equal to the number in the ability's notation (so a unit with BOMB4 carries up to 4 bombs). For most units, these bombs may be of any type, through battle armor units with this ability may only use cluster bombs (see p 183). (As a special exception, Arrow IV bombs must count the first Arrow IV missile carried this way as 2 bombs. All remaining bombs are then counted normally.) Each bomb a unit carries reduces its Thrust value by 1 (Battle armor units with bombs suffer no effects on their Move ratings.) A bomb-carrying unit's card should list how many bombs the unit is carrying in the scenario, which must be equal to or less than the number this ability enables it to carry. ")); + } + private ArrayList unitAbilityParser(String unitAbilities) { + return null; + } + public ArrayList getUnitAbilityDefinitions(String unitAbilities) { + return null; + } +} \ No newline at end of file diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/Bul.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/Bul.java new file mode 100755 index 0000000..06ff64b --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/Bul.java @@ -0,0 +1,39 @@ +package com.main.alphaunit.bul; + + +import android.os.AsyncTask; + +import androidx.loader.content.AsyncTaskLoader; + +import java.io.BufferedReader; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.List; + +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.Response; + +public class Bul { + private List units; + static String data; + public static String Get(String name) { + try { + URL urlForGetRequest = new URL("https://masterunitlist.azurewebsites.net/Unit/Filter?Types=18"); + OkHttpClient client = new OkHttpClient(); + Request request = new Request.Builder() + .url(urlForGetRequest) + .build(); + + try (Response response = client.newCall(request).execute()) { + return response.body().string(); + } + }catch (Exception e) { + + return e.toString(); + } + } + +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/MULApi.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/MULApi.java new file mode 100755 index 0000000..4d85293 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/MULApi.java @@ -0,0 +1,25 @@ +package com.main.alphaunit.bul; + +import android.content.Context; + +import com.google.gson.JsonObject; + +import java.util.List; + +import okhttp3.ResponseBody; +import retrofit2.Call; +import retrofit2.http.GET; +import retrofit2.http.Path; +import retrofit2.http.Query; +import retrofit2.http.Url; + +public interface MULApi { + String BaseURL = "https://masterunitlist.azurewebsites.net/"; + String test = "Atlas"; + + @GET("Unit/QuickList") + Call getMechs(@Query(value = "Name",encoded = true) String id); + + @GET("Unit/Card/{id}") + Call getMechImage(@Path(value = "id", encoded = true) String id, @Query(value = "skill",encoded = true) int skill); +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/MULClient.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/MULClient.java new file mode 100755 index 0000000..cbfc216 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/MULClient.java @@ -0,0 +1,60 @@ +package com.main.alphaunit.bul; + +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.media.Image; +import android.view.animation.Animation; +import android.widget.ImageView; + +import okhttp3.ResponseBody; +import retrofit2.Call; +import retrofit2.Callback; +import retrofit2.Response; +import retrofit2.Retrofit; +import retrofit2.converter.gson.GsonConverterFactory; + +public class MULClient { + private static MULClient instance = null; + private MULApi api; + + public interface ImageViewLoad { + void onLoad(Response response, Bitmap bitmap); + void onFail(Throwable throwable); + } + + private MULClient() { + Retrofit retrofit = new Retrofit.Builder().baseUrl(api.BaseURL) + .addConverterFactory(GsonConverterFactory.create()) + .build(); + api = retrofit.create(MULApi.class); + } + + public static synchronized MULClient getInstance() { + if (instance == null) { + instance = new MULClient(); + } + return instance; + } + + public static void getUnitImage(ImageView imageview, int id, int skill, ImageViewLoad imageViewLoad) { + + Call call =getInstance().getMULApi().getMechImage(Integer.toString(id), skill); + call.enqueue(new Callback() { + @Override + public void onResponse(Call call, Response response) { + Bitmap bitmap = BitmapFactory.decodeStream(response.body().byteStream()); + imageViewLoad.onLoad(response, bitmap); + + } + + @Override + public void onFailure(Call call, Throwable t) { + imageViewLoad.onFail(t); + + } + }); + } + public MULApi getMULApi() { + return api; + } +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/MULData.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/MULData.java new file mode 100755 index 0000000..3a459d9 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/MULData.java @@ -0,0 +1,6 @@ +package com.main.alphaunit.bul; + +public class MULData { + private String mechClass; + private String mechVarent; +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/Pilot.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/Pilot.java new file mode 100755 index 0000000..1997d88 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/Pilot.java @@ -0,0 +1,8 @@ +package com.main.alphaunit.bul; + +import java.io.Serializable; + +public class Pilot implements Serializable { + public int skill = 4; + public String name = "None"; +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/Unit.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/Unit.java new file mode 100755 index 0000000..fb539e4 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/Unit.java @@ -0,0 +1,122 @@ +package com.main.alphaunit.bul; + +import com.google.gson.GsonBuilder; +import com.google.gson.JsonObject; + +import java.io.Serializable; + +public class Unit implements Serializable { + public int id; + public int armor; + public int structure; + public int overheat; + public int damageShort, damageMedium, damageLong, damageExtreme; + public int baseBP; + public int tonnage; + public int tmm; + public Pilot pilot; + public String mechClass; + public String mechVariant; + public String role; + public String Abilities; + public String movement; + public String technology; + + public Unit() { + + this.id = 1; + this.armor = 1; + this.structure = 1; + this.overheat = 1; + this.damageShort = 1; + this.damageMedium = 1; + this.damageLong = 1; + this.damageExtreme = 1; + this.baseBP = 1; + this.tonnage = 1; + this.mechClass = "None"; + this.mechVariant = "None"; + this.role= "None"; + this.Abilities = "None"; + this.movement = "None"; + this.technology = "None"; + + } + + public Unit(int id, int armor, int structure, int overheat, int damageShort, int damageMedium, + int damageLong, int damageExtreme, int baseBP, int tonnage, int tmm, Pilot pilot, + String mechClass, String mechVariant, String role, String Abilities, String movement, + String technology) { + this.id = id; + this.armor = armor; + this.structure = structure; + this.overheat = overheat; + this.damageShort = damageShort; + this.damageMedium = damageMedium; + this.damageLong = damageLong; + this.damageExtreme = damageExtreme; + this.baseBP = baseBP; + this.tonnage = tonnage; + this.pilot = pilot; + this.mechClass = mechClass; + this.mechVariant = mechVariant; + this.role= role; + this.Abilities = Abilities; + this.movement = movement; + this.technology = technology; + + } + + @Override + public String toString() { + return new GsonBuilder().create().toJson(this, Unit.class); + } + + public String CalcTmm() { + int move; + if(movement.replace("\"","").replace("j","").replace("a","").replace("f","").split("/")[0] == ""){ + return ""; + } + move = Integer.valueOf(movement.replace("\"","") + .replace("j","") + .replace("a","") + .replace("t","") + .replace("f","") + .replace("m", "") + .replace("h", "") + .replace("n", "") + .replace("s", "") + .replace("v", "") + .replace("w", "") + .replace("(b)", "") + .replace("(w)", "") + .replace("g", "") + .split("/")[0]); + + if(move >= 0 && move <= 4) { + tmm = 0; + return Integer.toString(tmm); + } + else if(move >= 5 && move <= 8) { + tmm = 1; + return Integer.toString(tmm); + } + else if(move >= 9 && move <= 12) { + tmm = 2; + return Integer.toString(tmm); + } + else if(move >= 13 && move <= 18) { + tmm = 3; + return Integer.toString(tmm); + } + else if(move >= 19 && move <= 34) { + tmm = 4; + return Integer.toString(tmm); + } + else if(move >= 35){ + tmm = 5; + return Integer.toString(tmm); + } + return Integer.toString(tmm); + } +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitLists.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitLists.java new file mode 100755 index 0000000..a4abed4 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitLists.java @@ -0,0 +1,76 @@ +package com.main.alphaunit.bul; + +import android.content.Context; +import android.util.Log; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +public class UnitLists implements Serializable { + ArrayList units = new ArrayList<>(); + String listName; + String listDescription; + boolean selected = false; + int pointcount; + + public UnitLists(String name, String description) { + listName = name; + listDescription = description; + } + + private void setBp() { + Unit tmp; + pointcount = 0; + for (int i = 0; i < units.size(); i++) { + pointcount += units.get(i).baseBP; + } + } + + public void setUnits(ArrayList units) { + this.units = units; + } + public void select() { + selected = true; + } + public void deselect() { + selected = false; + } + public boolean isSelected() {return selected;} + public String getDescription() {return listDescription;} + public String getName() {return listName;} + public int getPointCount() {setBp(); return pointcount;} + + public void addUnit(Unit unit) { + units.add(unit); + setBp(); + } + + public void save(Context con) { + + FileOutputStream outputStream; + File t = new File(con.getFilesDir(),listName+".json"); + try { + t.createNewFile(); + outputStream = new FileOutputStream(t); + ObjectOutputStream objOutStream = new ObjectOutputStream(outputStream); + objOutStream.writeObject(units); + objOutStream.close(); + }catch (Exception e) { + Log.e("UNIT", "loadMasterSelection: Did not read to file:\n" + e.toString()); + } + } + + + + + public ArrayList getUnits() { + return units; + } +} + diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitListsManager.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitListsManager.java new file mode 100755 index 0000000..762c998 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitListsManager.java @@ -0,0 +1,55 @@ +package com.main.alphaunit.bul; + +import android.content.Context; +import android.util.Log; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.ArrayList; + +public class UnitListsManager { + + static UnitLists comUnitList; + public static ArrayList unitsLists = new ArrayList<>(); + public static void setSelectedUnitList(UnitLists unitList) { + if(comUnitList != null) { + comUnitList.deselect(); + } + unitList.select(); + comUnitList = unitList; + } + public static UnitLists getSelectedUnitList() { + + return comUnitList; + } + + public static void saveUnitLists(Context con) { + FileOutputStream outputStream; + File t = new File(con.getFilesDir(),"U.json"); + try { + t.createNewFile(); + outputStream = new FileOutputStream(t); + ObjectOutputStream objOutStream = new ObjectOutputStream(outputStream); + objOutStream.writeObject(unitsLists); + objOutStream.close(); + }catch (Exception e) { + Log.e("UNIT", "loadMasterSelection: Did not read to file:\n" + e.toString()); + } + } + public static void loadUnitLists(Context con) { + FileInputStream inputStream; + File t = new File(con.getFilesDir(),"U.json"); + try { + t.createNewFile(); + inputStream = new FileInputStream(t); + ObjectInputStream objInStream = new ObjectInputStream(inputStream); + unitsLists = (ArrayList)objInStream.readObject(); + objInStream.close(); + }catch (Exception e) { + Log.e("UNIT", "loadMasterSelection: Did not write to file\n" + e.toString()); + } + } +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitLists_RecyclerViewAdapter.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitLists_RecyclerViewAdapter.java new file mode 100755 index 0000000..07c35c3 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitLists_RecyclerViewAdapter.java @@ -0,0 +1,59 @@ +package com.main.alphaunit.bul; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.annotation.NonNull; +import androidx.recyclerview.widget.RecyclerView; + +import com.main.alphaunit.R; + +import java.util.ArrayList; + +public class UnitLists_RecyclerViewAdapter extends RecyclerView.Adapter { + Context context; + ArrayList unitLists; + public UnitLists_RecyclerViewAdapter(Context con, ArrayList unitLists) { + context = con; + this.unitLists = unitLists; + } + @NonNull + @Override + public UnitLists_RecyclerViewAdapter.MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) { + LayoutInflater inflater = LayoutInflater.from(context); + View view = inflater.inflate(R.layout.unitlist_card_layout,parent,false); + + return new UnitLists_RecyclerViewAdapter.MyViewHolder(view); + } + + @Override + public void onBindViewHolder(@NonNull UnitLists_RecyclerViewAdapter.MyViewHolder holder, int position) { + holder.name.setText("" +unitLists.get(position).listName); + holder.description.setText("" + unitLists.get(position).listDescription); + holder.battlePoints.setText("" + unitLists.get(position).getPointCount()); + holder.tonnage.setText("Tonnage"); + } + + @Override + public int getItemCount() { + return unitLists.size(); + } + + public static class MyViewHolder extends RecyclerView.ViewHolder { + + TextView name; + TextView description; + TextView battlePoints; + TextView tonnage; + public MyViewHolder(@NonNull View itemView) { + super(itemView); + name = itemView.findViewById(R.id.UnitListName); + description = itemView.findViewById(R.id.UnitListDescription); + battlePoints = itemView.findViewById(R.id.BattleValue); + tonnage = itemView.findViewById(R.id.Tonnage); + } + } +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitOnUITouch.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitOnUITouch.java new file mode 100755 index 0000000..e9045d6 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/UnitOnUITouch.java @@ -0,0 +1,63 @@ +package com.main.alphaunit.bul; + +import android.content.Context; +import android.view.GestureDetector; +import android.view.MotionEvent; +import android.view.View; + +import androidx.annotation.NonNull; +import androidx.recyclerview.widget.RecyclerView; + +public class UnitOnUITouch implements RecyclerView.OnItemTouchListener { + + private OnItemClickListener listener; + + + public interface OnItemClickListener { + public void onItemClick(View view, int position); + + public void onLongItemClick(View view, int position); + } + + GestureDetector gestureDetector; + + public UnitOnUITouch(Context context, final RecyclerView recyclerView, OnItemClickListener listener) { + this.listener = listener; + gestureDetector = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener() { + @Override + public boolean onSingleTapUp(MotionEvent e) { + return true; + } + + @Override + public void onLongPress(MotionEvent e) { + View child = recyclerView.findChildViewUnder(e.getX(), e.getY()); + if(child != null && listener != null) { + listener.onLongItemClick(child,recyclerView.getChildAdapterPosition(child)); + } + } + + }); + + } + + @Override + public boolean onInterceptTouchEvent(@NonNull RecyclerView rv, @NonNull MotionEvent e) { + View childView = rv.findChildViewUnder(e.getX(), e.getY()); + if(childView != null && listener != null && gestureDetector.onTouchEvent(e)) { + listener.onItemClick(childView, rv.getChildAdapterPosition(childView)); + return true; + } + return false; + } + + @Override + public void onTouchEvent(@NonNull RecyclerView rv, @NonNull MotionEvent e) { + + } + + @Override + public void onRequestDisallowInterceptTouchEvent(boolean disallowIntercept) { + + } +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/Unit_RecyclerViewAdapter.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/Unit_RecyclerViewAdapter.java new file mode 100755 index 0000000..eb62b84 --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/Unit_RecyclerViewAdapter.java @@ -0,0 +1,99 @@ +package com.main.alphaunit.bul; + +import android.content.Context; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import androidx.annotation.NonNull; +import androidx.recyclerview.widget.RecyclerView; + +import com.main.alphaunit.R; + +import java.util.ArrayList; + +public class Unit_RecyclerViewAdapter extends RecyclerView.Adapter { + + Context context; + ArrayList units; + + public Unit_RecyclerViewAdapter(Context context, ArrayList units) { + this.context = context; + this.units = units; + + } + + @NonNull + @Override + public Unit_RecyclerViewAdapter.MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) { + LayoutInflater inflater = LayoutInflater.from(context); + View view = inflater.inflate(R.layout.unit_card_layout,parent,false); + + return new Unit_RecyclerViewAdapter.MyViewHolder(view); + } + + @Override + public void onBindViewHolder(@NonNull Unit_RecyclerViewAdapter.MyViewHolder holder, int position) { + holder.mechClass.setText(""+units.get(position).mechClass); + holder.mechVar.setText(""+units.get(position).mechVariant); + holder.movement.setText(""+units.get(position).movement); + holder.BP.setText("PV: "+units.get(position).baseBP); + holder.Abilities.setText(""+units.get(position).Abilities); + holder.Armor.setText(""+units.get(position).armor); + holder.Structure.setText(""+units.get(position).structure); + holder.Role.setText(""+units.get(position).role); + holder.DamageShort.setText("+0\n"+units.get(position).damageShort); + holder.DamageMedium.setText("+2\n"+units.get(position).damageMedium); + holder.DamageLong.setText("+4\n"+units.get(position).damageLong); + holder.DamageExtreme.setText("+6\n"+units.get(position).damageExtreme); + holder.tmm.setText("TMM:"+units.get(position).CalcTmm()); + holder.overHeat.setText("OV:"+units.get(position).overheat); + holder.tonnage.setText("Tons:"+units.get(position).tonnage); + + + } + + @Override + public int getItemCount() { + return units.size(); + } + + public static class MyViewHolder extends RecyclerView.ViewHolder { + + TextView mechClass; + TextView mechVar; + TextView movement; + TextView overHeat; + TextView tonnage; + TextView pilotName; + TextView pilotSkill; + TextView BP; + TextView Abilities; + TextView Role; + TextView Armor, Structure; + TextView DamageShort, DamageMedium, DamageLong, DamageExtreme; + TextView tmm; + + public MyViewHolder(@NonNull View itemView) { + super(itemView); + mechClass = itemView.findViewById(R.id.Class); + mechVar = itemView.findViewById(R.id.Var); + movement = itemView.findViewById(R.id.Movement); + //pilotName = itemView.findViewById(R.id.PilotName); + //pilotSkill = itemView.findViewById(R.id.PilotSkill); + BP = itemView.findViewById(R.id.Bp); + Abilities = itemView.findViewById(R.id.Abilities); + Role = itemView.findViewById(R.id.Role); + Armor = itemView.findViewById(R.id.Armor); + Structure = itemView.findViewById(R.id.Structure); + DamageShort = itemView.findViewById(R.id.DamageShort); + DamageMedium = itemView.findViewById(R.id.DamageMedium); + DamageLong = itemView.findViewById(R.id.DamageLong); + DamageExtreme = itemView.findViewById(R.id.DamageExtreme); + tmm = itemView.findViewById(R.id.tmm); + overHeat = itemView.findViewById(R.id.Over_Heat_TV); + tonnage = itemView.findViewById(R.id.Tonnage_TextView); + } + } +} diff --git a/Sorce/app/src/main/java/com/main/alphaunit/bul/UserMasterUnitSelection.java b/Sorce/app/src/main/java/com/main/alphaunit/bul/UserMasterUnitSelection.java new file mode 100755 index 0000000..6b2333a --- /dev/null +++ b/Sorce/app/src/main/java/com/main/alphaunit/bul/UserMasterUnitSelection.java @@ -0,0 +1,123 @@ +package com.main.alphaunit.bul; + +import android.content.Context; +import android.os.Environment; +import android.util.Log; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonParser; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.OutputStreamWriter; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.ArrayList; + +public class UserMasterUnitSelection { + + private static ArrayList masterSelection; + + public static ArrayList getMasterSelection() { return masterSelection; } + public static void setMasterSelection(ArrayList units) { masterSelection = units; } + public static void addUnit(Unit unit) { masterSelection.add(unit); } + + public static ArrayList getUnitByName(String name) { + ArrayList unitsByName = new ArrayList(); + for (Unit unit : masterSelection) { + boolean hasUnit = false; + for (Unit unitb : unitsByName) { + if(unit.mechClass == unitb.mechClass){ + hasUnit = true; + break; + } + } + if(!hasUnit) { + unitsByName.add(unit); + } + } + return unitsByName; + } + + public static Unit getUnitById(int id) { + ArrayList unitsById = new ArrayList<>(); + for (Unit unit : masterSelection) { + if(unit.id == id) { + return unit; + } + } + return null; + } + + public static ArrayList getUnitsByRole(String role) { + ArrayList unitsByRole = new ArrayList<>(); + for (Unit unit : masterSelection) { + boolean hasUnit = false; + for (Unit unitb : unitsByRole) { + if(unit.mechClass == unitb.mechClass){ + hasUnit = true; + break; + } + } + if(!hasUnit) { + unitsByRole.add(unit); + } + } + return unitsByRole; + } + + public static ArrayList getUnitsBySize(int size) { + ArrayList unitsBySize = new ArrayList<>(); + for (Unit unit : masterSelection) { + boolean hasUnit = false; + for (Unit unitb : unitsBySize) { + if(unit.mechClass == unitb.mechClass){ + hasUnit = true; + break; + } + } + if(!hasUnit) { + unitsBySize.add(unit); + } + } + return unitsBySize; + } + + // loads the master list from the masterSelectionJson + public static void loadMasterSelection(Context con) { + FileOutputStream outputStream; + File t = new File(con.getFilesDir(),"test.json"); + try { + t.createNewFile(); + outputStream = new FileOutputStream(t); + ObjectOutputStream objOutStream = new ObjectOutputStream(outputStream); + objOutStream.writeObject(masterSelection); + objOutStream.close(); + }catch (Exception e) { + Log.e("UNIT", "loadMasterSelection: Did not read to file:\n" + e.toString()); + } + } + + // Saves the master list to a json file + public static void saveMasterSelection(Context con) { + FileInputStream inputStream; + File t = new File(con.getFilesDir(),"test.json"); + try { + t.createNewFile(); + inputStream = new FileInputStream(t); + ObjectInputStream objInStream = new ObjectInputStream(inputStream); + masterSelection = (ArrayList)objInStream.readObject(); + objInStream.close(); + }catch (Exception e) { + Log.e("UNIT", "loadMasterSelection: Did not write to file\n" + e.toString()); + } + } + +} diff --git a/Sorce/app/src/main/res/anim/blink.xml b/Sorce/app/src/main/res/anim/blink.xml new file mode 100755 index 0000000..89af34e --- /dev/null +++ b/Sorce/app/src/main/res/anim/blink.xml @@ -0,0 +1,21 @@ + + + + + + diff --git a/Sorce/app/src/main/res/anim/unitlist_move_up.xml b/Sorce/app/src/main/res/anim/unitlist_move_up.xml new file mode 100755 index 0000000..def47ae --- /dev/null +++ b/Sorce/app/src/main/res/anim/unitlist_move_up.xml @@ -0,0 +1,9 @@ + + + + + \ No newline at end of file diff --git a/Sorce/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/Sorce/app/src/main/res/drawable-v24/ic_launcher_foreground.xml new file mode 100755 index 0000000..2b068d1 --- /dev/null +++ b/Sorce/app/src/main/res/drawable-v24/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/Sorce/app/src/main/res/drawable/baseline_folder_24.xml b/Sorce/app/src/main/res/drawable/baseline_folder_24.xml new file mode 100755 index 0000000..c6237ca --- /dev/null +++ b/Sorce/app/src/main/res/drawable/baseline_folder_24.xml @@ -0,0 +1,5 @@ + + + diff --git a/Sorce/app/src/main/res/drawable/ic_launcher_background.xml b/Sorce/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100755 index 0000000..07d5da9 --- /dev/null +++ b/Sorce/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Sorce/app/src/main/res/drawable/list_view_icon.xml b/Sorce/app/src/main/res/drawable/list_view_icon.xml new file mode 100755 index 0000000..d84b4a6 --- /dev/null +++ b/Sorce/app/src/main/res/drawable/list_view_icon.xml @@ -0,0 +1,5 @@ + + + diff --git a/Sorce/app/src/main/res/drawable/mul_icon.xml b/Sorce/app/src/main/res/drawable/mul_icon.xml new file mode 100755 index 0000000..9b6e294 --- /dev/null +++ b/Sorce/app/src/main/res/drawable/mul_icon.xml @@ -0,0 +1,5 @@ + + + diff --git a/Sorce/app/src/main/res/drawable/quick_roles_tables.xml b/Sorce/app/src/main/res/drawable/quick_roles_tables.xml new file mode 100755 index 0000000..f5a9db0 --- /dev/null +++ b/Sorce/app/src/main/res/drawable/quick_roles_tables.xml @@ -0,0 +1,5 @@ + + + diff --git a/Sorce/app/src/main/res/layout/activity_main.xml b/Sorce/app/src/main/res/layout/activity_main.xml new file mode 100755 index 0000000..0860124 --- /dev/null +++ b/Sorce/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,153 @@ + + + + +