GA

Author: CSDotNET0211

Cargo.toml

@@ -16,6 +16,5 @@ thread-id = "*"
 once_cell = "*"
 libm = "*"
 
-
 [profile.release]
 debug = true

src/beemsearch.rs

@@ -71,7 +71,7 @@ impl BeemSearch {
         next_count: i8,
     ) -> i64 {
         let counter = Arc::new(AtomicUsize::new(0));
-        let next_count = 4;
+        let next_count = 5;
 
         //vec![1,2,3,4] -> 1234
         let mut next_int = 0;
@@ -128,6 +128,7 @@ impl BeemSearch {
             Action::NULL,
             0,
             false,
+            -1,
         );
 
         let mut beem_width = 0;
@@ -323,25 +324,25 @@ impl BeemSearch {
         lock_direction: i8,
         rotate_count: i32,
         move_flag: bool,
+        count_after_softdrop: i32,
     ) {
         if cfg!(debug_assertions) {
             if move_count > 11 {
                 panic!("ループしてない？");
             }
         }
+        if count_after_softdrop >= 3 {
+            return;
+        }
 
-        //ハードドロップ
-        {
-            /*
-            if move_value == 112 || move_value == 13 {
-                println!();
-            } */
-
-            let mut new_move_diff = Action::HARD_DROP as i64;
-            for _i in 0..move_count {
-                new_move_diff *= 10;
-            }
+        let mut new_move_diff = 1;
+
+        for _i in 0..move_count {
+            new_move_diff *= 10;
+        }
 
+        //ハードドロップ・ソフトドロップ
+        if count_after_softdrop != 0 {
             let mut newmino = mino.clone();
             let mut temp = 0;
 
@@ -355,6 +356,23 @@ impl BeemSearch {
 
             newmino.move_pos(0, -temp);
 
+            //ソフトドロップ
+            if count_after_softdrop == -1 {
+                if temp > 0 {
+                    Self::search(
+                        &mut newmino.clone(),
+                        &field,
+                        move_count + 1,
+                        move_value + new_move_diff * Action::SOFT_DROP as i64,
+                        before_eval,
+                        lock_direction,
+                        rotate_count,
+                        move_flag,
+                        0,
+                    )
+                }
+            }
+
             let hash =
                 Self::get_hash_for_position(newmino.mino_kind, newmino.rotation, &newmino.position);
 
@@ -363,13 +381,13 @@ impl BeemSearch {
                 if let Some(result) = searched_data.get_mut(&hash) {
                     if result.move_count > move_count {
                         result.move_count = move_count;
-                        result.move_value = move_value + new_move_diff;
+                        result.move_value = move_value + new_move_diff * Action::HARD_DROP as i64;
                     }
                 } else {
                     let mut pattern = SearchedPattern::new();
                     pattern.position = newmino.position;
                     pattern.move_count = move_count;
-                    pattern.move_value = move_value + new_move_diff;
+                    pattern.move_value = move_value + new_move_diff * Action::HARD_DROP as i64;
 
                     let mut field_clone = field.clone();
 
@@ -410,20 +428,24 @@ impl BeemSearch {
                 true,
             ) {
                 newmino.move_pos(Vector2::MX1.x, Vector2::MX1.y);
-                let mut temp = Action::MOVE_LEFT as i64;
-                for _i in 0..move_count {
-                    temp *= 10;
+
+                let softdrop_value;
+                if count_after_softdrop == -1 {
+                    softdrop_value = -1;
+                } else {
+                    softdrop_value = count_after_softdrop + 1;
                 }
 
                 Self::search(
                     &mut newmino,
                     &field,
                     move_count + 1,
-                    move_value + temp,
+                    move_value + new_move_diff * Action::MOVE_LEFT as i64,
                     &before_eval,
                     Action::MOVE_LEFT,
                     rotate_count,
                     true,
+                    softdrop_value,
                 );
             }
         }
@@ -443,28 +465,31 @@ impl BeemSearch {
             ) {
                 newmino.move_pos(Vector2::X1.x, Vector2::X1.y);
 
-                let mut temp = Action::MOVE_RIGHT as i64;
-                for _i in 0..move_count {
-                    temp *= 10;
+                let softdrop_value;
+                if count_after_softdrop == -1 {
+                    softdrop_value = -1;
+                } else {
+                    softdrop_value = count_after_softdrop + 1;
                 }
 
                 Self::search(
                     &mut newmino,
                     &field,
                     move_count + 1,
-                    move_value + temp,
+                    move_value + new_move_diff * Action::MOVE_RIGHT as i64,
                     &before_eval,
                     Action::MOVE_RIGHT,
                     rotate_count,
                     true,
+                    softdrop_value,
                 );
             }
         }
 
         let mut result = Vector2::ZERO;
         //右回転
         if !move_flag
-            && rotate_count < 3
+            && rotate_count < 2
             && Environment::try_rotate(Rotate::RIGHT, &field, mino, &mut result)
         {
             let mut newmino = mino.clone();
@@ -482,27 +507,30 @@ impl BeemSearch {
                 newmino.move_pos(result.x, result.y);
                 Environment::simple_rotate(Rotate::RIGHT, &mut newmino, 0);
 
-                let mut temp = Action::ROTATE_RIGHT as i64;
-                for _i in 0..move_count {
-                    temp *= 10;
+                let softdrop_value;
+                if count_after_softdrop == -1 {
+                    softdrop_value = -1;
+                } else {
+                    softdrop_value = count_after_softdrop + 1;
                 }
 
                 Self::search(
                     &mut newmino,
                     &field,
                     move_count + 1,
-                    move_value + temp,
+                    move_value + new_move_diff * Action::ROTATE_RIGHT as i64,
                     &before_eval,
                     lock_direction,
                     rotate_count + 1,
                     move_flag,
+                    softdrop_value,
                 );
             }
         }
 
         //左回転
         if !move_flag
-            && rotate_count < 3
+            && rotate_count < 2
             && Environment::try_rotate(Rotate::LEFT, &field, mino, &mut result)
         {
             let mut newmino = mino.clone();
@@ -520,23 +548,28 @@ impl BeemSearch {
                 newmino.move_pos(result.x, result.y);
                 Environment::simple_rotate(Rotate::LEFT, &mut newmino, 0);
 
-                let mut temp = Action::ROTATE_LEFT as i64;
-                for _i in 0..move_count {
-                    temp *= 10;
+                let softdrop_value;
+                if count_after_softdrop == -1 {
+                    softdrop_value = -1;
+                } else {
+                    softdrop_value = count_after_softdrop + 1;
                 }
 
                 Self::search(
                     &mut newmino,
                     &field,
                     move_count + 1,
-                    move_value + temp,
+                    move_value + new_move_diff * Action::ROTATE_LEFT as i64,
                     &before_eval,
                     lock_direction,
                     rotate_count + 1,
                     move_flag,
+                    softdrop_value,
                 );
             }
         }
+
+        //180回転
     }
 
     ///過去の位置を記録、参照
@@ -563,8 +596,9 @@ impl BeemSearch {
         result
     }
 
+    #[inline(always)]
     ///位置情報を回転情報関係なく均一にする
-    fn get_hash_for_position(kind: i8, rotation: i8, position: &i64) -> i64 {
+    pub fn get_hash_for_position(kind: i8, rotation: i8, position: &i64) -> i64 {
         if rotation == Rotation::ZERO {
             return *position;
         }

src/environment.rs

@@ -1,6 +1,7 @@
 //! テトリスシミュレート環境
 
 use core::panic;
+use once_cell::sync::Lazy;
 use rand::prelude::*;
 
 use crate::{beemsearch::BeemSearch, evaluation::Evaluation, WEIGHT};
@@ -580,6 +581,7 @@ impl Environment {
             Action::HARD_DROP => {
                 self.set_mino();
             }
+
             Action::SOFT_DROP => loop {
                 if Self::check_valid_pos(&self.field, &self.now_mino, &Vector2::MY1, 0) {
                     self.now_mino
@@ -588,6 +590,7 @@ impl Environment {
                     break;
                 }
             },
+
             Action::HOLD => self.hold(),
 
             _ => panic!("不明な型"),
@@ -899,7 +902,12 @@ impl Environment {
         let mut environment = Environment::new();
         environment.init();
 
-        WEIGHT.set(*weight);
+        //     let value = WEIGHT.get().unwrap();
+        unsafe {
+            *WEIGHT = *weight;
+        }
+        //   WEIGHT.set(*weight).unwrap();
+
         //検索
         //操作
         //終了条件確認(ライン消去数)

src/evaluation.rs

@@ -20,7 +20,11 @@ impl Evaluation {
 
     pub fn evaluate(field: &[bool], mino: &Mino, cleared_line: i32) -> f64 {
         let cleared_value;
-        let weight = WEIGHT.get().unwrap();
+        let weight;
+
+        unsafe {
+            weight = *WEIGHT;
+        }
 
         match cleared_line {
             0 => cleared_value = 0.0,

src/main.rs

@@ -11,6 +11,7 @@ use environment::{Action, Environment};
 use evaluation::Evaluation;
 use geneticalgorithm::GeneticAlgorithm;
 use num_cpus;
+use once_cell::sync::Lazy;
 use once_cell::sync::OnceCell;
 use std::time::{Duration, Instant};
 use std::{
@@ -21,7 +22,11 @@ use std::{
 use threadpool::ThreadPool;
 
 use crate::environment::MinoKind;
-pub static WEIGHT: OnceCell<[f64; Evaluation::WEIGHT_COUNT as usize]> = OnceCell::new();
+
+pub static mut WEIGHT: Lazy<[f64; Evaluation::WEIGHT_COUNT as usize]> = Lazy::new(|| {
+    let m = [0.0; Evaluation::WEIGHT_COUNT as usize];
+    m
+});
 pub static THREAD_POOL: OnceCell<Mutex<ThreadPool>> = OnceCell::new();
 
 //デバッグ用でスレッド数変えてる
@@ -33,22 +38,33 @@ fn main() {
         "スレッドプールの初期化失敗"
     );
 
-    assert!(
-        WEIGHT
-            .set([
-                200.1597, 319.1632, -1149.735, 118.6968, 187.1296, -604.2106, -551.1594, -364.9467,
-                -43.58047,
-            ])
-            .is_ok(),
-        "err"
-    );
+    unsafe {
+        *WEIGHT = [
+            -5628.7173895928445,
+            -2450.9359534946434,
+            12769.975461312846,
+            -22231.72228143262,
+            -11297.76613876014,
+            4526.680276187824,
+            -2796.0433150603876,
+            492.1132806920541,
+            3502.358375632634,
+        ];
+    }
 
-    GeneticAlgorithm::learn();
+    //  GeneticAlgorithm::learn();
+    let mut mino = Environment::create_mino_1(MinoKind::I);
+    println!(
+        "{}:{}",
+        BeemSearch::get_hash_for_position(mino.mino_kind, mino.rotation, &mino.position),
+        &mino.position
+    );
+    let mut buf = String::new();
+    io::stdin().read_line(&mut buf).unwrap();
 
     let mut environment = Environment::new();
     environment.init();
 
-    println!("何かキーを入力して検索を開始");
     let mut buf = String::new();
 
     let mut timer;
@@ -76,6 +92,14 @@ fn main() {
         for _i in 0..count {
             environment.user_input((result % 10).try_into().unwrap());
             result /= 10;
+
+            print(
+                &environment.get_field_ref(),
+                &environment.now_mino,
+                elapsed_time,
+            );
+
+            thread::sleep_ms(500);
         }
         /*
         let key = getch(false).unwrap();