Added support for float values in DELTA Buttons, fixed bug mentioned in

Farama-Foundation#182

Former-commit-id: 02e8c94

include/ViZDoomGame.h

@@ -51,9 +51,9 @@ namespace vizdoom {
         void replayEpisode(std::string filePath, unsigned int player = 0);
         bool isRunning();
 
-        void setAction(std::vector<int> const &actions);
+        void setAction(std::vector<double> const &actions);
         void advanceAction(unsigned int tics = 1, bool updateState = true);
-        double makeAction(std::vector<int> const &actions, unsigned int tics = 1);
+        double makeAction(std::vector<double> const &actions, unsigned int tics = 1);
 
         bool isNewEpisode();
         bool isEpisodeFinished();
@@ -62,7 +62,7 @@ namespace vizdoom {
         void sendGameCommand(std::string cmd);
 
         GameStatePtr getState();
-        std::vector<int> getLastAction();
+        std::vector<double> getLastAction();
 
 
         /* Buttons settings */
@@ -71,12 +71,12 @@ namespace vizdoom {
         std::vector<Button> getAvailableButtons();
         void setAvailableButtons(std::vector<Button> buttons);
 
-        void addAvailableButton(Button button, unsigned int maxValue = -1);
+        void addAvailableButton(Button button, double maxValue = -1);
         void clearAvailableButtons();
         size_t getAvailableButtonsSize();
 
-        void setButtonMaxValue(Button button, unsigned int maxValue);
-        int getButtonMaxValue(Button button);
+        void setButtonMaxValue(Button button, double maxValue);
+        double getButtonMaxValue(Button button);
 
 
         /* GameVariables getters and setters */
@@ -195,7 +195,7 @@ namespace vizdoom {
 
         std::vector<GameVariable> availableGameVariables;
         std::vector<Button> availableButtons;
-        std::vector<int> lastAction;
+        std::vector<double> lastAction;
 
         unsigned int nextStateNumber;
         unsigned int lastMapTic;

src/lib/ViZDoomController.cpp

@@ -815,12 +815,12 @@ namespace vizdoom {
 
     SMGameState *const DoomController::getGameState() { return this->gameState; }
 
-    int DoomController::getButtonState(Button button) {
+    double DoomController::getButtonState(Button button) {
         if (this->doomRunning) return this->input->BT[button];
         else return 0;
     }
 
-    void DoomController::setButtonState(Button button, int state) {
+    void DoomController::setButtonState(Button button, double state) {
         if (button < BUTTON_COUNT && button >= 0 && this->doomRunning)
             this->input->BT[button] = state;
     }
@@ -862,14 +862,14 @@ namespace vizdoom {
         }
     }
 
-    void DoomController::setButtonMaxValue(Button button, unsigned int value) {
+    void DoomController::setButtonMaxValue(Button button, double value) {
         if (button >= BINARY_BUTTON_COUNT) {
             if (this->doomRunning) this->input->BT_MAX_VALUE[button - BINARY_BUTTON_COUNT] = value;
             this->_input->BT_MAX_VALUE[button - BINARY_BUTTON_COUNT] = value;
         }
     }
 
-    int DoomController::getButtonMaxValue(Button button) {
+    double DoomController::getButtonMaxValue(Button button) {
         if (button >= BINARY_BUTTON_COUNT) {
             if (this->doomRunning) return this->input->BT_MAX_VALUE[button - BINARY_BUTTON_COUNT];
             else return this->_input->BT_MAX_VALUE[button - BINARY_BUTTON_COUNT];

src/lib/ViZDoomController.h

@@ -81,7 +81,6 @@ namespace vizdoom {
     public:
 
         DoomController();
-
         ~DoomController();
 
 
@@ -206,8 +205,8 @@ namespace vizdoom {
         SMGameState *const getGameState();
 
         /* Buttons state */
-        int getButtonState(Button button);
-        void setButtonState(Button button, int state);
+        double getButtonState(Button button);
+        void setButtonState(Button button, double state);
         void toggleButtonState(Button button);
 
         /* Buttons availableity */
@@ -216,8 +215,8 @@ namespace vizdoom {
         void resetButtons();
         void disableAllButtons();
 
-        int getButtonMaxValue(Button button);
-        void setButtonMaxValue(Button button, unsigned int value);
+        double getButtonMaxValue(Button button);
+        void setButtonMaxValue(Button button, double value);
         void availableAllButtons();
         bool isAllowDoomInput();
         void setAllowDoomInput(bool set);

src/lib/ViZDoomGame.cpp

@@ -123,7 +123,7 @@ namespace vizdoom {
         this->resetState();
     }
 
-    void DoomGame::setAction(std::vector<int> const &actions) {
+    void DoomGame::setAction(std::vector<double> const &actions) {
 
         if (!this->isRunning()) throw ViZDoomIsNotRunningException();
 
@@ -151,7 +151,7 @@ namespace vizdoom {
         }
     }
 
-    double DoomGame::makeAction(std::vector<int> const &actions, unsigned int tics) {
+    double DoomGame::makeAction(std::vector<double> const &actions, unsigned int tics) {
         this->setAction(actions);
         this->advanceAction(tics);
         return this->getLastReward();
@@ -246,7 +246,7 @@ namespace vizdoom {
 
     std::shared_ptr<GameState> DoomGame::getState() { return this->state; }
 
-    std::vector<int> DoomGame::getLastAction() { return this->lastAction; }
+    std::vector<double> DoomGame::getLastAction() { return this->lastAction; }
 
     bool DoomGame::isNewEpisode() {
         if (!this->isRunning()) throw ViZDoomIsNotRunningException();
@@ -280,7 +280,7 @@ namespace vizdoom {
         for(auto i : buttons) this->addAvailableButton(i);
     }
 
-    void DoomGame::addAvailableButton(Button button, unsigned int maxValue) {
+    void DoomGame::addAvailableButton(Button button, double maxValue) {
         if (!this->isRunning() && std::find(this->availableButtons.begin(),
                                             this->availableButtons.end(), button) == this->availableButtons.end()) {
             this->availableButtons.push_back(button);
@@ -296,11 +296,11 @@ namespace vizdoom {
         return this->availableButtons.size();
     }
 
-    void DoomGame::setButtonMaxValue(Button button, unsigned int maxValue) {
+    void DoomGame::setButtonMaxValue(Button button, double maxValue) {
         this->doomController->setButtonMaxValue(button, maxValue);
     }
 
-    int DoomGame::getButtonMaxValue(Button button) {
+    double DoomGame::getButtonMaxValue(Button button) {
         return this->doomController->getButtonMaxValue(button);
     }
 

src/lib/ViZDoomSharedMemory.h

@@ -158,9 +158,9 @@ namespace vizdoom {
     };
 
     struct SMInputState {
-        int BT[BUTTON_COUNT];
+        double BT[BUTTON_COUNT];
         bool BT_AVAILABLE[BUTTON_COUNT];
-        int BT_MAX_VALUE[DELTA_BUTTON_COUNT];
+        double BT_MAX_VALUE[DELTA_BUTTON_COUNT];
     };
 
     /* SM class */

src/lib_java/ViZDoomGameJava.cpp

@@ -36,12 +36,12 @@ JNI_METHOD(void, newEpisode__Ljava_lang_String, newEpisode_str, jstring)
 JNI_METHOD(void, replayEpisode__Ljava_lang_String_2, replayEpisode_str, jstring)
 JNI_METHOD(void, replayEpisode__Ljava_lang_String_2I, replayEpisode_str_int, jstring, jint)
 JNI_METHOD(jboolean, isRunning, isRunning)
-JNI_METHOD(void, setAction, setAction, jintArray)
+JNI_METHOD(void, setAction, setAction, jdoubleArray)
 JNI_METHOD(void, advanceAction__, advanceAction_)
 JNI_METHOD(void, advanceAction__I, advanceAction_int, jint)
 JNI_METHOD(void, advanceAction__IZ, advanceAction_int_bool, jint, jboolean)
-JNI_METHOD(jdouble, makeAction___3I, makeAction_vec, jintArray)
-JNI_METHOD(jdouble, makeAction___3II, makeAction_vec_int, jintArray, jint)
+JNI_METHOD(jdouble, makeAction___3I, makeAction_vec, jdoubleArray)
+JNI_METHOD(jdouble, makeAction___3II, makeAction_vec_int, jdoubleArray, jint)
 
 JNI_EXPORT(jobject, getState){
     auto state = callObjMethod(jEnv, jObj, &DoomGameJava::getState);
@@ -78,9 +78,9 @@ JNI_EXPORT(jobject, getState){
     return jState;
 }
 
-JNI_EXPORT(jintArray, getLastAction){
+JNI_EXPORT(jdoubleArray, getLastAction){
     auto lastAction = callObjMethod(jEnv, jObj, &DoomGameJava::getLastAction);
-    return castTojintArray(jEnv, lastAction);
+    return castTojdoubleArray(jEnv, lastAction);
 }
 
 JNI_METHOD(jboolean, isNewEpisode, isNewEpisode)
@@ -118,24 +118,24 @@ JNI_EXPORT(void, addAvailableButton__Lvizdoom_Button_2, jobject){
     callObjMethod(jEnv, jObj, &DoomGameJava::addAvailableButton_btn, arg1);
 }
 
-JNI_EXPORT(void, addAvailableButton__Lvizdoom_Button_2I, jobject, jint){
+JNI_EXPORT(void, addAvailableButton__Lvizdoom_Button_2I, jobject, jdouble){
     auto arg1 = jobjectCastToEnum<Button>(jEnv, "vizdoom/Button", jarg1);
-    auto arg2 = jintCast(jarg2);
+    auto arg2 = jdoubleCast(jarg2);
     callObjMethod(jEnv, jObj, &DoomGameJava::addAvailableButton_btn_int, arg1, arg2);
 }
 
 JNI_METHOD(void, clearAvailableButtons, clearAvailableButtons)
 JNI_METHOD(jint, getAvailableButtonsSize, getAvailableButtonsSize)
 
-JNI_EXPORT(void, setButtonMaxValue, jobject, jint){
+JNI_EXPORT(void, setButtonMaxValue, jobject, jdouble){
     auto arg1 = jobjectCastToEnum<Button>(jEnv, "vizdoom/Button", jarg1);
-    auto arg2 = jintCast(jarg2);
+    auto arg2 = jdoubleCast(jarg2);
     callObjMethod(jEnv, jObj, &DoomGameJava::setButtonMaxValue, arg1, arg2);
 }
 
-JNI_EXPORT(jint, getButtonMaxValue, jobject){
+JNI_EXPORT(jdouble, getButtonMaxValue, jobject){
     auto arg1 = jobjectCastToEnum<Button>(jEnv, "vizdoom/Button", jarg1);
-    return castTojint(callObjMethod(jEnv, jObj, &DoomGameJava::getButtonMaxValue, arg1));
+    return castTojdouble(callObjMethod(jEnv, jObj, &DoomGameJava::getButtonMaxValue, arg1));
 }
 
 JNI_EXPORT(jobjectArray, getAvailableGameVariables){

src/lib_java/ViZDoomGameJava.h

@@ -35,8 +35,8 @@ namespace vizdoom {
         void newEpisode_() { this->newEpisode(); };
         void newEpisode_str(std::string _str) { this->newEpisode(_str); };
 
-        double makeAction_vec(std::vector<int>& _vec){ return this->makeAction(_vec); }
-        double makeAction_vec_int(std::vector<int>& _vec, unsigned int _int){ return this->makeAction(_vec, _int); }
+        double makeAction_vec(std::vector<double>& _vec){ return this->makeAction(_vec); }
+        double makeAction_vec_int(std::vector<double>& _vec, unsigned int _int){ return this->makeAction(_vec, _int); }
 
         void advanceAction_() { this->advanceAction(); }
         void advanceAction_int(unsigned int _int) { this->advanceAction(_int); }
@@ -68,14 +68,14 @@ JNI_EXPORT(void, newEpisode__Ljava_lang_String, jstring);
 JNI_EXPORT(void, replayEpisode__Ljava_lang_String_2, jstring);
 JNI_EXPORT(void, replayEpisode__Ljava_lang_String_2I, jstring, jint);
 JNI_EXPORT(jboolean, isRunning);
-JNI_EXPORT(void, setAction, jintArray);
+JNI_EXPORT(void, setAction, jdoubleArray);
 JNI_EXPORT(void, advanceAction__);
 JNI_EXPORT(void, advanceAction__I, jint);
 JNI_EXPORT(void, advanceAction__IZ, jint, jboolean);
-JNI_EXPORT(jdouble, makeAction___3I, jintArray);
-JNI_EXPORT(jdouble, makeAction___3II, jintArray, jint);
+JNI_EXPORT(jdouble, makeAction___3I, jdoubleArray);
+JNI_EXPORT(jdouble, makeAction___3II, jdoubleArray, jint);
 JNI_EXPORT(jobject, getState);
-JNI_EXPORT(jintArray, getLastAction);
+JNI_EXPORT(jdoubleArray, getLastAction);
 JNI_EXPORT(jboolean, isNewEpisode);
 JNI_EXPORT(jboolean, isEpisodeFinished);
 JNI_EXPORT(jboolean, isPlayerDead);
@@ -84,11 +84,11 @@ JNI_EXPORT(void, respawnPlayer);
 JNI_EXPORT(jobjectArray, getAvailableButtons);
 JNI_EXPORT(void, setAvailableButtons, jobjectArray);
 JNI_EXPORT(void, addAvailableButton__Lvizdoom_Button_2, jobject);
-JNI_EXPORT(void, addAvailableButton__Lvizdoom_Button_2I, jobject, jint);
+JNI_EXPORT(void, addAvailableButton__Lvizdoom_Button_2I, jobject, jdouble);
 JNI_EXPORT(void, clearAvailableButtons);
 JNI_EXPORT(jint, getAvailableButtonsSize);
-JNI_EXPORT(void, setButtonMaxValue, jobject, jint);
-JNI_EXPORT(jint, getButtonMaxValue, jobject);
+JNI_EXPORT(void, setButtonMaxValue, jobject, jdouble);
+JNI_EXPORT(jdouble, getButtonMaxValue, jobject);
 
 JNI_EXPORT(jobjectArray, getAvailableGameVariables);
 JNI_EXPORT(void, setAvailableGameVariables, jobjectArray);

src/lib_java/ViZDoomJava.h

@@ -167,6 +167,15 @@ std::vector<int> jintArrayCast(JNIEnv *jEnv, jintArray jVal){
     return val;
 }
 
+std::vector<double> jdoubleArrayCast(JNIEnv *jEnv, jdoubleArray jVal){
+    int jValLen = jEnv->GetArrayLength(jVal);
+    jdouble *jValArr = jEnv->GetDoubleArrayElements(jVal, NULL);
+    std::vector<double> val;
+    for (int i=0; i<jValLen; ++i) val.push_back((int)jValArr[i]);
+    jEnv->ReleaseDoubleArrayElements(jVal, jValArr, NULL);
+    return val;
+}
+
 template<class T>
 T jobjectCastToEnum(JNIEnv *jEnv, const char* jClassName, jobject jEnum) {
     jclass jClass = jEnv->FindClass(jClassName);

src/lib_java/java_classes/DoomGame.java

@@ -14,10 +14,10 @@ public DoomGame(){
         this.DoomGameNative();
     }
 
-    public native int doomTics2Ms(double tics, int ticrate);
-    public native int ms2DoomTics(double ms, int ticrate);
-    public native int doomTics2Sec(double tics, int ticrate);
-    public native int sec2DoomTics(double sec, int ticrate);
+    public native double doomTics2Ms(double tics, int ticrate);
+    public native double ms2DoomTics(double ms, int ticrate);
+    public native double doomTics2Sec(double tics, int ticrate);
+    public native double sec2DoomTics(double sec, int ticrate);
     public native double doomFixedToDouble(double doomFixed);
     public native boolean isBinaryButton(Button button);
     public native boolean isDeltaButton(Button button);
@@ -35,16 +35,16 @@ public DoomGame(){
 
     public native boolean isRunning();
 
-    public native void setAction(int[] actions);
+    public native void setAction(double[] actions);
     public native void advanceAction();
     public native void advanceAction(int tics);
     public native void advanceAction(int tics, boolean stateUpdate);
-    public native double makeAction(int[] actions);
-    public native double makeAction(int[] actions, int tics);
+    public native double makeAction(double[] actions);
+    public native double makeAction(double[] actions, int tics);
 
     public native GameState getState();
 
-    public native int[] getLastAction();
+    public native double[] getLastAction();
 
     public native boolean isNewEpisode();
     public native boolean isEpisodeFinished();
@@ -55,12 +55,12 @@ public DoomGame(){
     public native Button[] getAvailableButtons();
     public native void setAvailableButtons(Button[] buttons);
     public native void addAvailableButton(Button button);
-    public native void addAvailableButton(Button button, int maxValue);
+    public native void addAvailableButton(Button button, double maxValue);
     public native void clearAvailableButtons();
     public native int getAvailableButtonsSize();
 
-    public native void setButtonMaxValue(Button button, int maxValue);
-    public native int getButtonMaxValue(Button button);
+    public native void setButtonMaxValue(Button button, double maxValue);
+    public native double getButtonMaxValue(Button button);
 
     public native GameVariable[] getAvailableGameVariables();
     public native void setAvailableGameVariables(GameVariable[] gameVariables);