Cube Solver

ตัวแก้ลูกบาศก์รูบิค

วิดีโอสาธิต: https://www.youtube.com/watch?v=A6JyElruhwE

สาธิต: http://d4m4s74.pythonanywhere.com/

คำอธิบาย:

โปรเจ็กต์สุดท้ายของฉันสำหรับ CS50 คือตัวแก้ลูกบาศก์รูบิค "วิธีของมนุษย์"
ซึ่งหมายความว่าลูกบาศก์รูบิกที่ป้อนเข้าไปนั้นได้รับการแก้ไขโดยใช้วิธีที่มนุษย์สามารถใช้ได้ (CFOP) โดยมีขั้นตอนที่ชัดเจน: Cross, F2L, OLL และ PLL
ผลิตภัณฑ์ขั้นสุดท้ายประกอบด้วยเชลล์แอปพลิเคชัน ไลบรารี C สำหรับใช้ในโครงการอื่น และเว็บอินเตอร์เฟสที่เขียนด้วย Flask, HTML, CSS และ Javascript

ฉันตัดสินใจสร้างตัวแก้ปัญหาลูกบาศก์ของรูบิคเพราะฉันเคยสร้างตัวแก้ปัญหาซูโดกุมาก่อนในภาษา C++ และลูกบาศก์ก็ก้าวขึ้นมาอีกขั้น
แทนที่จะเป็นระนาบ 2 มิติ ฉันกลับมีระนาบกึ่ง 3 มิติที่มีขอบและมุม
เนื่องจากตัวแก้ปัญหา AI เสร็จสิ้นแล้ว และฉันไม่มั่นใจในความสามารถในการเขียนของ AI มากพอ ฉันจึงตัดสินใจทำให้โปรแกรมแก้ปัญหาลูกบาศก์ในแบบที่ฉันทำ:
ครอส, F2L, OLL และ PLL

วิธีใช้

ตัวแก้ปัญหา

ลินุกซ์

ดาวน์โหลดไฟล์ปฏิบัติการ bin/solver หรือบิลด์จากแหล่งที่มาโดยใช้ make solver

OS X

ดาวน์โหลดหรือโคลนไฟล์จากที่เก็บนี้และสร้างโดยใช้ make solver

หน้าต่าง

ดาวน์โหลดหรือโคลนไฟล์โดยใช้พื้นที่เก็บข้อมูลนี้ และคอมไพล์ไฟล์ .c ทั้งหมดใน src ยกเว้น Solver_library

ทั้งหมด

รันโปรแกรมแก้ปัญหาด้วยคำสั่งใดคำสั่งหนึ่งต่อไปนี้:

 ./solver "Algorithm"
./solver [Up] [Front] [Right] [Back] [Left] [Down]

การแทนที่อัลกอริทึมด้วยอัลกอริทึมช่วงชิง (เช่น U R2 FBR B2 R U2 L B2 RU' D' R2 FR' L B2 U2 F2 ) หรือใบหน้าที่มีสีบนใบหน้านั้น (เช่น wbwowrwgw gwgogrgyg rwrgrbryr bwbrbobyb owobogoyo ygyoyryby )
สีที่เป็นไปได้คืออักขระตัวแรกของสีเขียว สีแดง สีน้ำเงิน สีส้ม สีขาว และสีเหลือง
หากไฟล์ olls.txt และ plls.txt ไม่ได้อยู่ในโฟลเดอร์เดียวกันกับไบนารี ให้ใช้ตัวเลือก -o และ -p หรือ -d เพื่อชี้ไปที่ไฟล์

 bin/solver -d data/ "U R2 F B R B2 R U2 L B2 R U' D' R2 F R' L B2 U2 F2"
bin/solver -o data/olls.csv -p data/plls.csv "U R2 F B R B2 R U2 L B2 R U' D' R2 F R' L B2 U2 F2"

เพิ่มตัวเลือก -t เพื่อพิมพ์เฉพาะข้อความที่ไม่มีรูปภาพของคิวบ์

เว็บอินเตอร์เฟส

ลินุกซ์:

ดาวน์โหลดหรือโคลนไฟล์จากที่เก็บนี้
ติดตั้ง Flask และ Numpy โดยใช้ pip

 python3 -m pip -r requirements.txt

ใช้คำสั่ง flask run หรือ python3 app.py เพื่อรันเว็บเซิร์ฟเวอร์
ไปที่ https://127.0.0.1:5000/ เพื่อใช้ตัวแก้ปัญหา

OS X:

ดาวน์โหลดหรือโคลนไฟล์จากที่เก็บนี้
ลบ bin/libcubesolver.so เวอร์ชัน Linux ด้วยตนเอง หรือใช้ make clean และคอมไพล์ใหม่โดยใช้ make library
ติดตั้ง Flask และ Numpy โดยใช้ pip:

 python3 -m pip -r requirements.txt

ใช้คำสั่ง flask run หรือ python3 app.py เพื่อรันเว็บเซิร์ฟเวอร์
ไปที่ https://127.0.0.1:5000/ เพื่อใช้ตัวแก้ปัญหา

หน้าต่าง:

ดาวน์โหลดหรือโคลนไฟล์จากที่เก็บนี้ ลบ bin/libcubesolver.so เวอร์ชัน Linux ด้วยตนเอง
คอมไพล์ไฟล์ .c ทั้งหมดใน src ยกเว้น solver.c ไปที่ bin/libcubesolver.so หรือหากใช้ชื่ออื่น ให้เปลี่ยนบรรทัด 19 ใน app.py เพื่อสะท้อนถึงสิ่งนั้น
ติดตั้ง Flask และ Numpy โดยใช้ pip:

 python3 -m pip -r requirements.txt

ใช้คำสั่ง flask run หรือ python3 app.py เพื่อรันเว็บเซิร์ฟเวอร์
ไปที่ https://127.0.0.1:5000/ เพื่อใช้ตัวแก้ปัญหา

ไลบรารีตัวแก้ปัญหา

ติดตั้งเพื่อใช้กับ C หรือ C++

รวบรวมไฟล์ทั้งหมดใน src ยกเว้น Solver.c เป็น libcubesolver.so, libcubesolver.dylib หรือ libcubesolver.dll และบันทึกไว้ทุกที่ที่ไลบรารีถูกบันทึกไว้ในพีซีของคุณ
บน Linux คุณสามารถใช้ make library ได้
คัดลอก libcubesolver.h จาก src ไปยังทุกที่ที่ส่วนหัวถูกบันทึกไว้ในพีซีของคุณ (เช่น /usr/include/)

การใช้งานด้วย C หรือ C++

เชื่อมโยงกับ -lcubesolver หรือเพียงแค่คอมไพล์ลงในแอปพลิเคชันราวกับว่าเป็นไฟล์ .o

 #include 
#include 
//Use either setup, or both load_olls and load_plls.
//Load all OLLs and PLLs into memory. Path is the folder where the olls.csv and plls.csv file are located.
//Returns indicating for succes or failure.
setup ( path );
//Loads the OLLs from a CSV file. Returns bool indicating success or failure.
load_olls ( filename );
//Loads the PLLs from a CSV file. Returns bool indicating success or failure.
load_plls ( filename );
//Create an array to hold the cube. 6 faces, 9 squares per face.
//The faces in order are Front, Right, Back, Left, Up and Down.
//The "Colors" are saved as the numbers 0 to 5.
int cube [ 6 ][ 9 ];
//Add the "colors" of the cube to the array as 9 character strings containing numbers 0 to 5.
color_cube ( cube , front , right , back , left , up , down );
//Run a multiple move algorithm on the cube, using standard cube notation. (Useful for scrambling)
run_algorithm ( cube , "Algorithm" );
/*
A function that prints the sides of the cube in an exploded fashion. Uses colors when in linux or OS X
Uses Green for 0, Red for 1, Blue for 2, Orange for 3, White for 4, Yellow for 5
    WWW
    WWW
    WWW

OOO GGG RRR BBB
OOO GGG RRR BBB
OOO GGG RRR BBB

    YYY
    YYY
    YYY
*/
print_cube ( cube );
//Validate the colors on the cube for impossible cubies. This does not check if the scramble is solvable.
//Returns bool.
if (! validate ( cube ))
{
    return "Invalid color combinaton" ;
}
//returns pointer to string containing all algorithms used to solve the cube, separated by newlines,
//and the names of the steps. (eg. Cross, F2L, OLL: Sune, PLL: Y perm)
//Modifies the array to its solved position
char * solution = solve ( cube );
// Returns:
/*
Cross
(R D' F D)
(y) (R D' F D)
(y) (R D' F D)
(y) (R D' F D)

F2L
(y) R U R' U R U' R') (d' L U L')
(y2) (L' U' L) (y') (U' F' U F) (R' F R F')
(d2 R' U2 R2 U R2 U R)
(y) (U R U R' U2) (d R' U2 R) (U' R B' R' B)

OLL: Kite
(y2) (R U R' U') R' F R2 U R' U' F'

PLL: G perm c
(y2) L' R' U2 L R (y) L U' R U2 L' U R'
*/

//Generates a cube from an algorithm and returns pointer to its solution, or an error if unsolvable.
char * solution2 = solve_scramble ( "scramble" );
//Solves the (yellow) cross.
//Returns a pointer to a string containing the solve algorithm, with each solved edge separated by newlines.
//May also return an error if unsolvable.
//Modifies the cube array to have a solved cross.
char * cross = solve_cross ( cube );
//Solves the first two layers of the cube assuming a solved cross.
//Returns a string containing the solve algorithm, with each solved pair separated by newlines.
//Modifies the cube array to solve its f2l.
//Returns null if the cube is unsolvable.
char * f2l = solve_f2l ( cube );
//Looks up the right OLL algorithm and runs it, assuming a solved F2L.
//Returns the name of the OLL, and the algorithm, separated by a newline.
//Returns null if the cube is unsolvable.
char * oll = solve_oll ( cube );
//Looks up the right PLL algorithm and runs it, assuming a solved OLL.
//Returns the name of the PLL, and the algorithm, separated by a newline.
//Returns null if the cube is unsolvable.
char * pll = solve_pll ( cube );

การใช้งานกับหลาม

ดูเวอร์ชัน C เพื่อดูว่าแต่ละฟังก์ชันทำอะไร
เนื่องจากเป็นการยากที่จะเพิ่มหน่วยความจำ malloced ใน python ให้ใช้ฟังก์ชันการแก้ปัญหาเวอร์ชัน "ปลอดภัย" และใช้ free_strings() หลังการใช้งาน

 import numpy
import ctypes
# Most functions will need a c 2d int array. Let's give it a name so it's easy to use.
array_2d_int = numpy . ctypeslib . ndpointer (
    dtype = ctypes . c_int , ndim = 2 , flags = 'CONTIGUOUS' )
# First load the solver library using ctypes CDLL.
solver = ctypes . CDLL ( "/path/to/libcubesolver.so" )
# Then we set up all functions we might want to use.
# Setup, load_olls and load_plls require a string.
solver . setup . argtypes = [ ctypes . c_char_p ]
solver . load_olls . argtypes = [ ctypes . c_char_p ]
solver . load_olls . argtypes = [ ctypes . c_char_p ]
# Run_algorithm requires a 2d array for the cube, and a string.
solver . run_algorithm . argtypes = [ array_2d_int , ctypes . c_char_p ]
# All other functions require just the 2d array.
solver . print_cube . argtypes = [ array_2d_int ]
solver . validate . argtypes = [ array_2d_int ]
solver . solve_safe . argtypes = [ array_2d_int ]
solver . solve_cross_safe . argtypes = [ array_2d_int ]
solver . solve_f2l_safe . argtypes = [ array_2d_int ]
solver . solve_oll_safe . argtypes = [ array_2d_int ]
solver . solve_pll_safe . argtypes = [ array_2d_int ]
# For functions that return something other than an int (or bool) we also need to set the response type.
solver . solve_safe . restype = ctypes . c_char_p
solver . solve_cross_safe . restype = ctypes . c_char_p
solver . solve_f2l_safe . restype = ctypes . c_char_p
solver . solve_oll_safe . restype = ctypes . c_char_p
solver . solve_pll_safe . restype = ctypes . c_char_p
# Load the olls and plls csvs. in my case they're in the data folder.
# Use .encode('utf-8') to convert the python string to a c string.
solver . setup ( "data" . encode ( 'utf-8' ))
# Set up a cube. The inner lists, in order, are Front, Right, Back, Left, Up and Down.
# By default 0 = green, 1 = red, 2 = blue, 3 = orange, 4 = white, 5 = yellow.
solvedcube = [[ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ],
              [ 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 ],
              [ 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 ],
              [ 3 , 3 , 3 , 3 , 3 , 3 , 3 , 3 , 3 ],
              [ 4 , 4 , 4 , 4 , 4 , 4 , 4 , 4 , 4 ],
              [ 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 , 5 ]]
# Turn it into a C 2d array.
cube = numpy . array ( solvedcube ). astype ( ctypes . c_int )
# Run a scramble on the array. Use .encode('utf-8') to change the python string to a c string.
solver . run_algorithm (
    cube , "U R2 F B R B2 R U2 L B2 R U' D' R2 F R' L B2 U2 F2" . encode ( 'utf-8' ))
# Print the cube to the shell.
solver . print_cube ( cube )
# Validate the color comibinations on the cube.
if not validate ( cube ):
    return "Invalid color combinaton"
# Solve the cube using solver.solve.
# Note: running the function also modifies the cube array.
solution = solver . solve_safe ( cube ). decode ( "utf-8" )
# Returns:
"""
Cross
(R D' F D)
(y) (R D' F D)
(y) (R D' F D)
(y) (R D' F D)

F2L
(y) R U R' U R U' R') (d' L U L')
(y2) (L' U' L) (y') (U' F' U F) (R' F R F')
(d2 R' U2 R2 U R2 U R)
(y) (U R U R' U2) (d R' U2 R) (U' R B' R' B)

OLL: Kite
(y2) (R U R' U') R' F R2 U R' U' F'

PLL: G perm c
(y2) L' R' U2 L R (y) L U' R U2 L' U R'
"""
# Or returns an error if the cube is unsolvable.

# You can also do the steps separately.
# solve the cross.
cross = solver . solve_cross_safe ( cube ). decode ( "utf-8" )
# returns
'''
(R D' F D)
(y) (R D' F D)
(y) (R D' F D)
(y) (R D' F D)
'''
# solve the F2L.
f2l = solver . solve_f2l_safe ( cube ). decode ( "utf-8" )
# returns
'''
(y) R U R' U R U' R') (d' L U L')
(y2) (L' U' L) (y') (U' F' U F) (R' F R F')
(d2 R' U2 R2 U R2 U R)
(y) (U R U R' U2) (d R' U2 R) (U' R B' R' B)
'''
# solve the OLL.
oll = solver . solve_oll_safe ( cube ). decode ( "utf-8" )
# returns
'''
Kite
(y2) (R U R' U') R' F R2 U R' U' F'
'''
# solve the PLL.
pll = solver . solve_pll_safe ( cube ). decode ( "utf-8" )
# returns
'''
G perm c
(y2) L' R' U2 L R (y) L U' R U2 L' U R'
'''
# If a step is already solved, the functions return an empty string.
# With an unsolvable cube, these functions return NULL, which causes an
# AttributeError when trying to decode. You may want to verify before decoding. (or use try)

# Clean up the memory for the solution strings.
solver . free_strings ()
# Finally clean up the loaded OLLs or PLLs to prevent memory leaks
solver . cleanup_last_layer ()

โครงสร้าง

CS50 ต้องการให้ฉันอธิบายว่าทุกไฟล์ทำหน้าที่อะไร และมีอะไรอยู่ในนั้น ดังนั้น readme นี้จึงยาวกว่าไฟล์ทั้งหมดของฉันยกเว้น 3 ไฟล์

 ├── app.py  
├── ถังขยะ  
│ ├── libcubesolver.so  
│ └── ตัวแก้ปัญหา  
├── ข้อมูล  
│ ├── ข้อผิดพลาด.txt  
│ ├── olls.csv  
│ ├── patterns.csv  
│ └── plls.csv  
├── เมคไฟล์  
├── README.md  
├── ข้อกำหนด.txt  
├── src  
│ ├── ข้าม.ค  
│ ├── ข้าม.h  
│ ├── cube.c  
│ ├── คิวบ์.ช  
│ ├── cubesolver.h  
│ ├── f2l.c  
│ ├── f2l.h  
│ ├── Lastlayer.c  
│ ├── Lastlayer.h  
│ ├── แก้ปัญหา.c  
│ ├── solver_library.c    
│ ├── utils.c  
│ └── utils.h  
├── ทดสอบ  
│ ├── สุ่มทดสอบค  
│ └── การทดสอบแบบสุ่ม   
├── คงที่  
│ ├── cube.css  
│ ├── cube.js  
│ ├── cubeinterface.js  
│ ├── favicon.ico  
│ ├── ถัดไป.png  
│ ├── Pause.png  
│ ├── play.png  
│ └── prev.png  
├── เทมเพลต  
│ ├── cube.html  
│ └── Solver.html  

src

cube.c และ cube.h

Cube.c และ cube.h มีโค้ดทั้งหมดที่ควบคุมลูกบาศก์รูบิคในหน่วยความจำ

ลูกบาศก์รูบิกในหน่วยความจำคืออาร์เรย์ 2 มิติขนาด 6 x 9 อาร์เรย์ด้านนอกประกอบด้วยหกหน้า: ด้านหน้า ขวา หลัง ซ้าย ขึ้น และลง
ฉันเลือกลำดับนี้เพราะว่าหน้าขึ้นและลงจะเหมือนกันเสมอ ดังนั้นฉันจึงสามารถฮาร์ดโค้ดพวกมันได้ แต่ด้านข้างจะต้องถูกต้องโดยสัมพันธ์กันเท่านั้น ซึ่งหมายความว่าฉันสามารถใช้บวกหรือลบอย่างง่าย รวมกับโมดูลัสเพื่อแปลการทดสอบและเคลื่อนไปทุกด้าน เช่นเดียวกับสีต่างๆ ซึ่งบันทึกเป็นตัวเลข 0 ถึง 5, 0 คือสีด้านหน้า, 1 คือด้านขวา ฯลฯ
ก่อนอื่นฉันเลือกลำดับสีที่ฉันใช้: สีแดงด้านหน้า สีเหลืองด้านบน สีเขียวทางด้านขวา แต่ต่อมาเมื่อเขียนโค้ด Python และอินเทอร์เฟซ ฉันเปลี่ยนเป็นสีเขียว "อย่างเป็นทางการ" ด้านหน้า สีขาวด้านบน ดังนั้นฉันจึงไม่จำเป็นต้องหมุนลูกบาศก์ที่ผู้ใช้ป้อนเพื่อให้มีสีขาวที่ด้านล่าง

color_cube()

ก่อนอื่นฉันสร้างฟังก์ชัน color_cube() สิ่งนี้ใช้รูปแบบที่คุณเลือกกับคิวบ์โดยใช้ 6 สาย
ใช้คณิตศาสตร์แบบถ่านอย่างง่ายในการเปลี่ยนถ่าน '0', '1' ฯลฯ เป็น int และจัดเก็บอาร์เรย์ที่กำหนด
ฉันใช้สิ่งนี้เพียงครั้งเดียวหรือสองครั้งเป็นซับเดียวในการตั้งค่าคิวบ์ที่แก้ไขแล้วในบรรทัดเดียว เพราะเมื่อแปลอินพุตของผู้ใช้เป็นสิ่งที่คอมพิวเตอร์เข้าใจ คุณอาจป้อน ints ทีละรายการ แทนที่จะแปลเป็นสตริงก่อน

print_cube()

Print_cube() ส่งออกคิวบ์ที่ให้มาไปยังเทอร์มินัล ซึ่งใช้บ่อยมากในการดีบักและสำหรับแอปพลิเคชันเทอร์มินัล ฉันเริ่มต้นด้วยการแสดงตัวเลข 0 ถึง 5 ออกมาเป็นรูปลูกบาศก์รูบิกที่ระเบิด

    444
    444
    444

333 000 111 222
333 000 111 222
333 000 111 222

    555
    555
    555

เพราะมันจะสร้างบรรทัดโค้ดมากขึ้นเพื่อทำให้สิ่งนี้เป็นอัตโนมัติ ฉันจึงใช้คำสั่งพิมพ์ 9 รายการ โดยแต่ละคำสั่งมีตัวแปรสูงสุด 12 ตัว
ต่อมาฉันพบว่าฉันสามารถเพิ่มโค้ดเชลล์เช่น e[42m เพื่อให้ตัวเลขเหล่านี้เป็นสีพื้นหลังได้ การเพิ่มสิ่งเหล่านี้ทำให้ฉันมี 28 ตัวแปรต่อการพิมพ์
ในที่สุดฉันก็คิดที่จะใส่ตัวอักษรหรือตัวเลขสำหรับสีในอาร์เรย์ที่เก็บรหัสเชลล์โดยนำกลับมาเป็น 12 น่าเสียดายที่ Windows ไม่รองรับรหัสเชลล์ประเภทนี้ ดังนั้นฉันจึงต้องใช้เพียงตัวเลขต่อไป และ ตัวอักษรต่อมา

move_cube()

Move_cube() เป็นฟังก์ชันแรกสำหรับการเปลี่ยนคิวบ์จริงๆ นี่คือฟังก์ชันแบบเรียกซ้ำที่จะย้ายตามจำนวนครั้งที่ร้องขอ มีการเคลื่อนไหวที่เป็นไปได้ 9 แบบ โดยมีหมายเลข 0 ถึง 8 โดยเป็นค่าเริ่มต้นด้านหน้า ขวา ด้านหลัง ฯลฯ แต่ยังรวมถึงชั้นกลาง เส้นศูนย์สูตร และชั้นยืนด้วย การใช้ฟังก์ชันตัวช่วยที่ฉันเขียนใน utils.c เรียกว่า Cycle ฉันสลับค่าของแต่ละช่องสี่เหลี่ยมบนแต่ละหน้าตามการเคลื่อนไหวตามเข็มนาฬิกา โดยทำซ้ำหากจำเป็น

run_อัลกอริทึม()

เนื่องจากการเคลื่อนไหวมักจะไม่เกิดขึ้นเอง ต่อไปฉันจะเขียน run_algorithm() ฟังก์ชันนี้ใช้ move_cube() เพื่อรันอัลกอริทึมบนคิวบ์ที่ให้มาในรูปแบบคิวบ์มาตรฐาน สิ่งนี้ทำให้ฉันสามารถทำการเคลื่อนไหวหลาย ๆ ครั้งพร้อมกัน (หรือตามลำดับ) และทำการเคลื่อนไหวที่มีผลกระทบต่อ 2 หรือ 3 เลเยอร์ เช่น x, y และ z

ตรวจสอบความถูกต้อง()

ในที่สุด ตรวจสอบ () ฉันเพิ่มฟังก์ชันนี้ในขณะที่เขียนอินเทอร์เฟซ Python เพราะคุณไม่ควรเชื่อถือผู้ใช้ของคุณว่าจะไม่ป้อนสิ่งแปลก ๆ
ฟังก์ชันนี้ไม่ได้ตรวจสอบว่าลูกบาศก์รูบิคสามารถแก้ไขได้หรือไม่ จะตรวจสอบว่าสีถูกต้องหรือไม่ ตัวอย่างเช่น หนึ่งคิวบีไม่สามารถมีทั้งสติกเกอร์สีขาวและสีเหลืองได้ และเมื่อหมุนตามเข็มนาฬิกา ก็เป็นไปได้ที่จะมีสติ๊กเกอร์สีเขียว สีขาว และสีแดงตามลำดับ แต่ไม่ใช่ในทางกลับกัน
ในการดำเนินการนี้ ฉันได้คัดลอกแนวคิดเกี่ยวกับอาร์เรย์ที่ถูกล็อกใน Tideman บางส่วน โดยใช้อาร์เรย์บูลีน 2d สำหรับมุม และอาร์เรย์บูลีน 3 มิติสำหรับขอบเพื่อดูว่าสามารถผสมสี 2 หรือ 3 สีเข้าด้วยกันได้หรือไม่ รหัสนี้ผ่านการวนซ้ำหลายครั้ง ขั้นแรกให้ตรวจสอบแต่ละขอบและมุมแยกกัน จากนั้นใช้สองสามลูปในภายหลัง

cross.c และ cross.h

Cross.c มีโค้ดทั้งหมดที่จำเป็นในการแก้ครอสของคิวบ์ เนื่องจากฉันใช้ "วิธีของมนุษย์" (CFOP) เพื่อแก้ลูกบาศก์ ฉันจึงถูกบังคับให้ใช้แผนผังการตัดสินใจขนาดใหญ่
ฉันเขียนไฟล์ใหม่เกือบทั้งหมดในนาทีที่แล้ว ดังนั้นจึงไม่ต้องจัดขอบทุกขั้นตอน

ค้นหาศูนย์()

ค้นหาว่าขอบสีเหลืองเขียวอยู่ที่ไหนในชั้นล่างสุด หรือจะอยู่ตรงไหนหากยังไม่มี ซึ่งจะทำให้ง่ายต่อการจัดแนวขอบอื่นๆ ด้วยขั้นตอนที่น้อยลง เนื่องจากสามารถจัดแนวให้เป็น "ศูนย์สัมพัทธ์" แทนที่จะเป็นศูนย์จริงได้

crossCase1() ถึง 6

กรณีทั้ง 6 นี้เป็นทุกวิถีทางที่จะวางขอบได้ ชี้ลง ชี้ขึ้น ชี้ออกในชั้นขึ้นและลง ชี้ไปทางซ้ายและชี้ขวาบนชั้น E
โดยทั่วไปแล้ว ฟังก์ชันจะสแกนใบหน้าตามลำดับจาก 0 ถึง 3 เพื่อค้นหาชิ้นส่วนที่อยู่ในกากบาท หมุนให้เข้าที่ และจัดเก็บการเคลื่อนไหวในอาร์เรย์ถ่านโดยใช้ฟังก์ชันตัวช่วยที่ฉันเรียกว่า append()

แก้ปัญหา_ข้าม()

ขั้นแรก Solve_cross จะปรับทิศทางลูกบาศก์ให้เหลืองลง จากนั้นจะทำการครอสเคสทั้ง 6 ตามลำดับ หากมีใครส่งคืนอย่างอื่นที่ไม่ใช่ null มันจะกลับไปที่กรณีแรก
เมื่อแก้ไขทั้ง 4 ขอบแล้ว ฟังก์ชันจะส่งคืนอัลกอริธึม หากทุกกรณีได้รับการทดสอบไม่สำเร็จ หรือหลังจาก 4 ลูป ฟังก์ชันจะคืนค่า NULL

f2l.c และ f2l.h

แนวคิดเดียวกันกับ cross.c ยกเว้นที่ใหญ่กว่ามาก รหัส 3,600 บรรทัดเพื่อแก้ไขทุกกรณี

f2lCase1() ถึง 11

กรณีทั้ง 11 กรณีนี้ประกอบด้วยทุกวิถีทางในการวางมุม และการผสมผสานมุมและขอบบางส่วน
เพื่อประหยัดเวลาและเส้น ฟังก์ชันส่วนใหญ่ไม่ได้แก้ปัญหาการรวมมุม/ขอบอย่างสมบูรณ์ แต่นำมาสู่สถานะที่ทราบสั้นที่สุดและเรียกใช้ฟังก์ชันที่ถูกต้อง
เลข 1 ถึง 11 คือลำดับที่เขียน ไม่ใช่ลำดับที่เขียนเสมอไป

แก้ปัญหา_f2l()

Solve_f2l ตรวจสอบก่อนว่ากากบาทได้รับการแก้ไขแล้ว ถ้าไม่เช่นนั้นจะคืนค่าเป็นโมฆะ
หลังจากนั้น solve_f2l จะพิจารณากรณีต่างๆ ตามลำดับอัลกอริทึมเฉลี่ยที่สั้นที่สุดไปหายาวที่สุด โดยจะกลับไปเป็น 1 เมื่อฟังก์ชันส่งคืนอัลกอริทึม หากทุกกรณีได้รับการทดสอบโดยไม่สำเร็จ หรือหลังจาก 4 ลูป ฟังก์ชันจะคืนค่า NULL

Lastlayer.c และ Lastlayer.h

ไฟล์ที่ฉันภูมิใจที่สุด ไม่มีวงจรขนาดใหญ่ ไม่มีแผนผังการตัดสินใจ เพียงแค่คณิตศาสตร์ที่ชาญฉลาดและตารางการค้นหา

struct oll และ pll

Oll และ pll เป็นสองโครงสร้างที่มีไว้เพื่อจัดเก็บ OLL และ PLL พวกเขาเก็บชื่อ รูปแบบที่ฉันใช้จดจำ และอัลกอริธึมในการแก้ปัญหา
ในคืนนอนไม่หลับ ฉันคิดว่าฉันจำ PLL ได้โดยใช้เพียงสีของวงแหวนรอบนอก และ OLL เพียง 12 บูลีนหมายถึงสีเหลืองหรือไม่ใช่สีเหลือง

load_olls() และ load_plls()

Load_olls() และ load_plls() โหลดชื่อ รูปแบบ และอัลกอริทึมจากไฟล์ CSV สิ่งนี้ผ่านการวนซ้ำบางอย่าง
ฉันเริ่มต้นด้วย getline() เพื่อรับไฟล์ CSV แต่ละบรรทัด และแยกสตริงที่ 24 อักขระ และ 36 อักขระ โดยเติมชื่อด้วยการเว้นวรรค
มันไม่สวยเลยฉันเริ่มมองหาลูกน้ำและแยกสิ่งต่าง ๆ ตรงนั้น
ในที่สุดก็มีใครบางคนที่ไม่ลงรอยกันแนะนำให้ฉันไปที่ sscanf() ทำให้ฉันแยกแต่ละสตริงได้อย่างง่ายดายและหมดจด
ฉันยังเปลี่ยนมาใช้ fgets() เพื่อให้สายสามารถใช้งานร่วมกันได้มากขึ้น
บรรทัดที่ขึ้นต้นด้วย # ถูกปฏิเสธเนื่องจากเป็นความคิดเห็น เส้นที่รูปแบบไม่ได้เป็นตัวเลขล้วนๆ จะถูกจดจำโดยใช้ฟังก์ชันตัวช่วยที่เรียกว่า isNumber() หรือ isBinary() และถูกปฏิเสธ และในขณะที่เขียนส่วนนี้ ฉันได้เพิ่มการทดสอบเพื่อดูว่าชื่อ รูปแบบ และอัลกอริทึมมีความยาวที่เหมาะสมหรือไม่ หยุดการอ่านและเขียนนอกขอบเขต
ในพื้นที่อาร์เรย์ olls และ plls สำหรับชื่อและอัลกอริทึมจะถูกสร้างขึ้นโดยใช้ malloc และข้อมูลจะถูกคัดลอกโดยใช้ strncpy รูปแบบจะเปลี่ยนเป็นอาร์เรย์ 12 ints หรือบูลีน

find_oll() และ find_pll()

Find_pll() คือความภาคภูมิใจและความสุขของฉัน มันเป็นอัลกอริธึมแรกที่ฉันเขียนเพื่อแก้ลูกบาศก์ (ก่อนกากบาทและ f2l) และมันก็มาหาฉันในความฝัน วิธีตรวจสอบรูปแบบ oll เพื่อหาการผสมสีใดๆ ก็ตามด้วยคณิตศาสตร์ง่ายๆ ฉันตื่นขึ้นมาแล้วจด int case[12] containing the outer ring. if (front[0] == (front[1]-(case[0]-case[1])%4)) ลงไป int case[12] containing the outer ring. if (front[0] == (front[1]-(case[0]-case[1])%4)) วันถัดไปฉันทำให้มันง่ายขึ้นเป็น (faces[0][0] == (faces[0][1] - (plls[i].pattern[0] - plls[i].pattern[1])) % 4) (คูณ 12) จากนั้น (faces[j][0] - faces[j][1]) % 4 == (plls[i].pattern[0] - plls[i].pattern[1]) % 4 และสุดท้ายหลังจากการวนซ้ำหลายครั้ง ฉันลงเอยด้วย mod((cube[(j + i / 3) % 4][i % 3] + dif[j]), 4) ทำให้ฉันสามารถเข้ารหัสรูปแบบของชั้นบนสุดของคิวบ์โดยใช้ อาร์เรย์ int 12 ตัว เพื่อให้ง่ายต่อการเปรียบเทียบกับค่าที่ทราบทั้งหมด
ฉันสามารถเข้ารหัสรูปแบบเป็น int 4 ไบต์ได้ แต่ฉันตัดสินใจไม่ทำเพราะฉันคิดว่าเป็นการดีกว่าที่จะทำให้รูปแบบเข้าใจง่ายกว่าบันทึก 44 ไบต์ (รวม 3408 kb สำหรับรูปแบบ)
สุดท้ายฟังก์ชันจะส่งกลับค่า pair_int_int ที่มีการวางแนวของเลเยอร์ และ OLL หรือ PLL ที่ถูกต้อง หรือจำนวนลบสองตัวหากไม่พบสิ่งใดเลย

solve_oll() และ solve_pll()

ฟังก์ชัน solve_oll() และ solve_pll() นั้นค่อนข้างง่าย พวกเขาเรียก find_oll หรือ pll เพื่อรับดัชนีและการวางแนวที่ถูกต้อง (จำนวนการเคลื่อนไหว y) จากนั้นฟังก์ชันจะเปลี่ยนคิวบ์โดยใช้การเคลื่อนที่แบบ y รันอัลกอริธึม OLL หรือ PLL ที่ถูกต้อง และในกรณีของ solve_pll() จะเปลี่ยนเลเยอร์ U เพื่อแก้โจทย์คิวบ์ในที่สุด ฟังก์ชันส่งคืนอัลกอริทึมที่ใช้ในการแก้คิวบ์ในรูปแบบคิวบ์มาตรฐาน

cleanup_last_layer()

เพิ่มหน่วยความจำที่ใช้สำหรับจัดเก็บ OLL และ PLL ทั้งหมด

utils.c และ utils.h

ฟังก์ชั่นบางอย่างที่ทำให้ชีวิตของฉันง่ายขึ้นเล็กน้อย

ม็อด()

เนื่องจาก % ปกติใช้ไม่ได้กับจำนวนลบ นี่คือ "เวอร์ชันของฉันเอง" ที่ใช้งานได้ ขอขอบคุณเป็นพิเศษสำหรับความไม่ลงรอยกันของ cs50

make_pair_int_int()

สำหรับบางฟังก์ชันฉันต้องการส่งคืนตัวแปรมากกว่าหนึ่งตัว อันนี้ขึ้นอยู่กับคู่ C++ และ make_pair() มันสร้างโครงสร้างที่มีสอง ints: ตัวแรกและตัวที่สอง ในกรณีนี้ ใช้เพื่อส่งคืนหมายเลข oll/pll และการย้าย U หรือ y ก่อนหน้า

วงจร()

ฟังก์ชันที่วนรอบตัวเลข 4 ตัว โดยพื้นฐานแล้วก้าวขึ้นมาจากการแลกเปลี่ยน ใช้ใน cube.c เพื่อวนขอบและมุมสำหรับการเคลื่อนที่ของลูกบาศก์ มีสำเนาของการย้ายนั้นใน cube.js

ผนวก()

ฟังก์ชันที่เพิ่มสตริงให้กับสตริงอื่น จัดสรรใหม่หากจำเป็น ใช้ทุกที่ในแอปพลิเคชันนี้

isNumber() และ isBinary()

ตรวจสอบว่าสตริงมีเพียงตัวเลขหรือเฉพาะเลขศูนย์และหลักเท่านั้น ปัจจุบันใช้สำหรับการโหลด OLL และ PLL เท่านั้น

Solver_library.c และ cubesolver.h

ตอนแรกฉันเขียน Solver.c เป็นอินเทอร์เฟซสำหรับตัวแก้คิวบ์ของฉัน แต่ตัดสินใจอย่างรวดเร็วว่าต้องการ UI แบบกราฟิก ซึ่งฉันไม่พร้อมที่จะทำใน Pure C
นั่นเป็นเหตุผลที่ฉันเริ่มสร้าง cubesolvers ของฉันให้เป็นไลบรารีเพื่อใช้กับทุกสิ่งที่ฉันต้องการ

แก้ปัญหา()

รวบรวมทั้งหมดเข้าด้วยกันเพื่อแก้ลูกบาศก์ ต้องใช้คิวบ์และตรวจสอบความถูกต้อง แล้วจึงพยายามแก้ไม้กางเขน หากล้มเหลวจะส่งคืนข้อผิดพลาด มิฉะนั้นจะเก็บเอาต์พุตไว้ จากนั้นจะแก้ไขการครอสหรือส่งคืนข้อผิดพลาด จากนั้นจะแก้ OLL (หรือส่งคืน) และ PLL ในที่สุดก็ส่งคืนสตริงที่มีโซลูชันแบบเต็ม

แก้ปัญหา_แย่งชิง()

อินเทอร์เฟซสำหรับการแก้ปัญหา สร้างคิวบ์จากการแย่งชิงที่ป้อนและส่งผ่านเพื่อแก้ไข ()

การตั้งค่า()

เพียงเพื่อให้ชีวิตของทุกคนง่ายขึ้นอีกนิด ใช้เส้นทางและโหลด ols และ ppls จากเส้นทางนั้น คืนค่าเป็นจริงหากใช้งานได้ ล้างข้อมูลภายหลัง และคืนค่าเท็จหากไม่ได้ผล

store_string_pointer()

เนื่องจากเป็นการยากที่จะเพิ่มหน่วยความจำจาก Python ฉันจึงตัดสินใจทำจาก C ฉันมีทุกฟังก์ชันในเวอร์ชัน "ปลอดภัย" ที่คุณอาจต้องการใช้จากภายนอก C สิ่งเหล่านี้จะจัดเก็บพอยน์เตอร์ที่สร้างขึ้นซึ่งจำเป็นต้องปล่อยลงในอาเรย์ส่วนกลาง เพื่อปลดปล่อยทั้งหมดในคราวเดียว

free_strings()

ฟรีทริกที่เก็บไว้ทั้งหมด

solve_safe(), solve_scramble_safe(), solve_cross_safe(), solve_f2l_safe(), solve_oll_safe() และ solve_pll_safe()

หลายฟังก์ชันส่งคืนสตริงซึ่งจำเป็นต้องได้รับการปลดปล่อยในตอนท้าย ฟังก์ชันเหล่านี้จัดเก็บพอยน์เตอร์ไปยังสตริงเหล่านี้เพื่อการลบในภายหลัง

แก้ปัญหา.c

สำหรับการทดสอบและผู้ที่ใช้คีย์บอร์ดดีกว่าเมาส์คืออินเทอร์เฟซเทอร์มินัล
มีการเขียนซ้ำหลายครั้ง ในที่สุดก็ถูกเขียนใหม่ในขณะที่เขียน readme นี้เพื่อทำงานกับ Solver_library แทนที่จะเป็นตัวมันเอง

หลัก()

มันทำทุกอย่าง! โดยจะโหลด OLL และ PLL ตามค่าเริ่มต้นหรืออินพุตของผู้ใช้ จากนั้นจะสร้างคิวบ์ตามบรรทัดคำสั่งหรืออินพุตของผู้ใช้ และสุดท้ายจะแก้ไขคิวบ์ทีละขั้นตอน โดยพิมพ์คิวบ์ไปพร้อมกัน

getDir()

รับไดเร็กทอรีจากพาธไฟล์ที่กำหนด (เช่น argv[0]) เขียนขึ้นเพื่อทำงานร่วมกับ OS ที่ใช้ Windows และ Unix

color_letter_to_number()

เปลี่ยนตัวอักษรสีเป็น int ที่สอดคล้องกัน ในหลามฉันเพิ่งใช้พจนานุกรม ง่ายกว่ามาก

color_face_from_input()

ถามผู้ใช้ถึงเก้าสีของหน้าลูกบาศก์รูบิค และวางไว้บนลูกบาศก์

color_cube_interactive()

อินเทอร์เฟซแบบโต้ตอบทีละขั้นตอนสำหรับการป้อนสีลงบนลูกบาศก์

ข้อความช่วยเหลือ()

พิมพ์การทดสอบความช่วยเหลือ

การใช้งาน()

พิมพ์การใช้งาน

ทดสอบ

สุ่มทดสอบ.c

แอปพลิเคชั่นสั้น ๆ ง่ายๆ สำหรับการทดสอบข้อบกพร่อง ทำให้เกิดการแย่งชิงจำนวนมากและแก้ไขได้ พิมพ์ช่วงชิงแรกที่ล้มเหลวและหยุด
ฉันใช้สิ่งนี้เพื่อค้นหาการพิมพ์ผิดเพียงครั้งเดียว ทุกสิ่งทุกอย่างที่ฉันทำด้วยตนเอง

ตรวจสอบแก้ไขแล้ว ()

ใช้ memcmp เพื่อเปรียบเทียบคิวบ์ที่คายออกมาโดยอัลกอริธึมการแก้ปัญหากับหนึ่งใน 4 คิวบ์ที่แก้ไขแล้ว (หนึ่งอันต่อการวางแนว)
แลกหน่วยความจำเล็กน้อยเพื่อความเร็ว

Generate_scramble()

สร้างการแย่งชิงลูกบาศก์รูบิคแบบสุ่ม ห่วย. ไม่ป้องกันการเคลื่อนที่สองครั้งและการเคลื่อนที่แบบย้อนกลับ แต่ก็ดีพอถ้าช่วงชิงยาวพอ

หลัก()

โหลด OLL และ PLL จากอินพุตของผู้ใช้ แก้ปัญหาคิวบ์ได้หลายครั้งตามที่ผู้ใช้ต้องการ จนกว่าจะล้มเหลว

ข้อมูล

olls.csv

ประกอบด้วยรายการเคส OLL ทั้งหมด 58 เคส (รวมถึงที่แก้ไขแล้ว) เพื่อใช้กับไลบรารี C ของฉัน
อัลกอริทึมจากหน่วยความจำของฉันเอง และจาก https://www.speedulating.com/wiki/index.php/OLL

pls.csv

ประกอบด้วยรายการกรณี PLL ทั้งหมด 22 กรณี (รวมถึงที่แก้ไขแล้ว) เพื่อใช้กับไลบรารี C ของฉัน
อัลกอริทึมจากหน่วยความจำของฉันเอง และจากhttps://www.speedulating.com/wiki/index.php/PLL

patterns.csv

มีรูปแบบไม่กี่รูปแบบสำหรับการแย่งชิงลูกบาศก์ด้วยวิธีที่สวยงาม ส่วนใหญ่ใช้สำหรับทดสอบจาวาสคริปต์ของฉัน แต่เป็นคุณสมบัติที่ดีสำหรับผู้ใช้

error.txt

หวังว่าจะไม่มีอะไร แต่มีไว้เพื่อจัดเก็บข้อผิดพลาดใดๆ ในการแก้ไขคิวบ์

-

app.py

สะพานเชื่อมระหว่างรหัส C ของฉันและจาวาสคริปต์ มันโหลดไลบรารี C และเริ่มต้นฟังก์ชันที่ฉันต้องการด้วย argtypes และหากจำเป็น restypes การใช้ numpy เพื่อแปลงจากประเภท python เป็น ctypes

แบ่งส่วน()

ฟังก์ชั่นที่ฉัน "ยืม" จาก stackoverflow รับอินพุตสตรีมและเอาต์พุตทุกบรรทัดสูงถึง #

ก้าวกระโดด()

ตัวแก้ที่แท้จริง ใช้คิวบ์ที่มีสัญญาณรบกวนและแก้ไขทีละขั้นตอน โดยส่งคืนขั้นตอนเป็นอาร์เรย์ของพจนานุกรม (ประกอบด้วยอาร์เรย์ที่มีอัลกอริทึม) ในกรณีที่มีข้อยกเว้น ระบบจะจัดเก็บรูปแบบไว้ใน data/errors.txt

อินเทอร์เฟซการแก้ปัญหา ()

ใช้สำหรับการทดสอบเท่านั้น ใช้อัลกอริทึมช่วงชิงจาก GET แก้ปัญหาโดยใช้ getsteps() แล้วส่งต่อไปยังเทมเพลตของโปรแกรมแก้ปัญหา

ตัวแก้ปัญหา JSON()

ใช้รูปแบบและการแย่งชิงจาก GET หรือ POST แก้ไขโดยใช้ getsteps และส่งกลับเป็น JSON

เครื่องมือตรวจสอบ JSON()

ใช้รูปแบบจาก GET หรือ POST และแก้ไขคิวบ์ โดยไม่สนใจโซลูชันที่แท้จริง แต่ตรวจสอบว่าระบบล้มเหลวหรือไม่ ส่งกลับ 0 สำหรับความสำเร็จหรือหมายเลขข้อผิดพลาด

คิวบ์()

แสดงเทมเพลต cube.html: UI จริง แม้ว่าจะทำเช่นนั้น แต่ก็ยังนำรูปแบบจาก data/patterns.csv มามอบให้กับเทมเพลต โดยใช้ dictreader และ decomment เพื่อลบความคิดเห็นของฉัน

ไอคอน Fav()

ส่ง favicon ไปยังเบราว์เซอร์เพื่อหาสัญลักษณ์คิวบ์ที่ดี

การล้างข้อมูล()

เพิ่มหน่วยความจำทั้งหมดจากรหัส C ของฉัน: PLL และสตริง ลงทะเบียนโดยใช้ atexit เพื่อวิ่งที่ทางออก

เมคไฟล์

คำสั่งทั้งหมดสำหรับการคอมไพล์โค้ด C ของฉันบน Linux หรือ OS X แม้ว่าไลบรารีของฉันจะสามารถใช้เป็นไลบรารีได้ แต่ฉันตัดสินใจใช้ไฟล์ทั้งหมดในการคอมไพล์ ดังนั้นฉันจึงสามารถแจกไฟล์ปฏิบัติการได้เพียงไฟล์เดียว

ข้อกำหนด.txt

ประกอบด้วยไลบรารีสองไลบรารีที่ฉันใช้ซึ่งจำเป็นต้องติดตั้งแยกกัน เพียงขวดและจำนวน ไม่มีอะไรพิเศษ

แม่แบบ

แก้ปัญหา.html

ขอช่วงชิงส่งไปที่ app.py เพื่อแก้ไขและพิมพ์วิธีแก้ปัญหา ใช้สำหรับการทดสอบอย่างรวดเร็วเท่านั้น

cube.html

มี div ว่างจำนวนมากที่ต้องกรอกด้วยโค้ด javascript ของฉัน และจัดรูปแบบด้วย css ประกอบด้วยรูปภาพ 3 รูปสำหรับส่วนควบคุมการเล่น แบบฟอร์มสำหรับการเข้าสู่ช่วงชิง และคำอธิบายสั้นๆ
ในที่สุดก็โหลดจาวาสคริปต์เพราะมันไม่มีอะไรเลยหากไม่มี dom ไม่สวยเท่าไหร่ แต่ใช้งานได้ดีมาก

คงที่

ยกเว้น src มีรหัสจริงที่สุด CSS บางตัวเพื่อทำให้ทุกอย่างดูใช้งานได้ และ JavaScript เพื่อทำให้ทุกอย่างดูใช้งานได้จริง และภาพบางส่วนให้คลิก

cube.css

เปลี่ยนลิงค์ของ div แบบสุ่มเป็นสิ่งที่คุณสามารถเห็นได้
ใช้กริด CSS เป็นค่าเริ่มต้น และใช้วิธีเริ่มต้นน้อยกว่า
ฉันใช้คอนเทนเนอร์ภายนอกเพื่อวางส่วนควบคุมทางด้านซ้าย ภาพเคลื่อนไหวของตัวแก้ปัญหาด้านบนขวา และด้านล่างขวาของโซลูชัน
การใช้การวางตำแหน่งแบบสัมบูรณ์ ฉันวางส่วนควบคุมการเล่นและ alg ปัจจุบันไว้เหนือภาพเคลื่อนไหว
ทุกอย่างอื่นค่อนข้างเป็นค่าเริ่มต้นยกเว้นเครื่องมือเลือกสี หากคุณดูโค้ด html คุณจะเห็น div ที่มี 6 div โดยแต่ละ div มี 9 div การใช้กริด ฉันจัดรูปร่าง div "ใบหน้า" ทั้ง 6 ส่วนให้มีลักษณะเหมือนลูกบาศก์ที่กางออก โดยแต่ละหน้าจะมีตารางจำนวน 9 สี่เหลี่ยม ซึ่งช่วยให้ฉันสร้างตัวแปรขนาดได้ในขณะที่รูปร่างยังคงเหมือนเดิม โดยไม่จำเป็นต้องใช้รูปภาพ
ฉันยังใช้เวลาหนึ่งหรือ 2 สัปดาห์ในการสร้างมุมมองบนมือถือ เนื่องจากข้อความดูเหมือนจะมีขนาดที่เปลี่ยนแปลงได้ ฉันติดต่อกับ Discord, Facebook และแม้กระทั่ง Stackoverflow ในที่สุดฉันก็พบบรรทัด html บน stackoverflow: ซึ่งแก้ไขทุกอย่างในบรรทัดเดียว

cube.js

นำอัลกอริทึมของฉันมาสู่ผู้ใช้ อ้างอิงจาก three.js
นี่เป็นครั้งแรกที่ฉันเขียนจาวาสคริปต์จริงๆ มันอาจจะดูไม่สวย อาจจะแหกกฎทั้งหมด แต่มันก็ได้ผล

ฉันเขียนไฟล์นี้ใหม่หลายครั้ง ทำซ้ำครั้งแรก นั่นคือก่อนที่ฉันจะเริ่มอัปโหลดไปยัง GitHub จากนั้นก็ใช้งานได้ และสุดท้ายก็เป็นแบบเชิงวัตถุ
ก่อนอื่น ฉันประกาศตัวแปรทั้งหมดที่จำเป็นต้องใช้โดยมากกว่าหนึ่งฟังก์ชัน: วัสดุและเรขาคณิตสำหรับวัตถุ three.js, อาร์เรย์สำหรับจัดเก็บวัตถุ, แกนการหมุน และอื่นๆ
นอกจากนี้ยังมีพจนานุกรมขนาดยักษ์ที่มีตัวแปรที่จำเป็นสำหรับการเคลื่อนที่ของคิวบ์ตามกฎหมายทุกครั้ง เช่น ลูกบาศก์ที่จะวนหรือสลับ แกนและองศาของการหมุน และสิ่งที่จะแสดง ทั้งหมดนี้สามารถมีได้ 72 บรรทัด แต่ style50 ต้องการหนึ่งตัวแปรต่อบรรทัด ทำให้เป็น 649 บรรทัด

ตัวสร้าง ()

ถ่ายฉากและบันทึกข้อมูลอ้างอิง สร้างคิวบีส์ โครงร่างและระนาบในวงวน กำหนดตำแหน่งของคิวบีและโครงร่างในวง และระนาบด้วยตนเอง

วงจร_การหมุน()

ฟังก์ชั่นตัวช่วย วนการหมุนของ 4 ลูกบาศก์ a > b > c > d > a โดยใช้ลูกบาศก์อุณหภูมิ

swap_rotations()

ฟังก์ชั่นตัวช่วย สลับการหมุนของ 2 ลูกบาศก์โดยใช้ลูกบาศก์อุณหภูมิ

รีเซ็ต_คิวบ์()

รีเซ็ตคิวบ์เป็นตำแหน่งเริ่มต้นและรีเซ็ต div โซลูชัน สิ่งนี้ต้องการขั้นตอนมากกว่าที่คุณคิด ก่อนอื่นเราต้องรีเซ็ตแอนิเมชั่นทั้งหมดให้เสร็จสิ้น รีเซ็ตการเคลื่อนไหวในอนาคตและอดีตทั้งหมด และในที่สุดก็รีเซ็ตการหมุนของลูกบาศก์

is_moving()

ส่งคืนค่าจริงหรือเท็จขึ้นอยู่กับว่าคิวบ์กำลังเคลื่อนที่หรือไม่

ทำ_ย้าย()

ตั้งค่าภาพเคลื่อนไหวสำหรับการเคลื่อนที่บนลูกบาศก์
เดิมทีฟังก์ชันนี้มี 160 บรรทัดของคำสั่ง if/else แต่ต่อมาฉันเขียนมันใหม่เพื่อรับลูกบาศก์และย้ายจากพจนานุกรมขนาดยักษ์ ซึ่งทำให้อ่านฟังก์ชันนี้และฟังก์ชันถัดไปได้ง่ายขึ้น และหากฉันเขียนเวอร์ชัน 4x4 หรือ 5x5 ฉันแค่ต้องเปลี่ยนพจนานุกรมเท่านั้น

เสร็จสิ้น_ย้าย()

ทำแอนิเมชั่นให้เสร็จสิ้น และย้าย (หมุน) ลูกบาศก์จริงๆ
เนื่องจากลูกบาศก์ไม่ขยับจริงๆ แนวคิดพื้นฐานคือการคัดลอกการหมุนของลูกบาศก์ที่จะย้ายมาแทนที่ลูกบาศก์จริงแล้วจึงหมุนทุกอย่าง
เดิมทีฟังก์ชันนี้เป็นเพียงความน่ากลัว 375 บรรทัดของคำสั่ง if/else ถัดไป ต่อมาถูกเขียนใหม่เพื่อทำงานกับพจนานุกรมการเคลื่อนไหว

ถัดไป_ย้าย()

เคลื่อนที่ถัดไปในรายการการเคลื่อนไหว หรืออัลกอริทึมถัดไปในรายการขั้นตอน และแสดงอัลกอริทึมปัจจุบันบนหน้าจอ

ก่อนหน้า_ย้าย()

การย้ายครั้งก่อนหน้าเขาย้ายรายการแบบย้อนกลับหรืออัลกอริทึมก่อนหน้าในรายการขั้นตอน

Apply_รูปแบบ()

นำสีจากตัวเลือกสี (หรืออาร์เรย์ใบหน้า) ไปใช้กับลูกบาศก์โดยการหมุนแต่ละลูกบาศก์ มีฟังก์ชันบางอย่างของตัวเอง แต่ละลูกบาศก์จะมีไลน์ของตัวเองพร้อมตัวปรับแต่งแบบแมนนวล สำหรับฉันมันสุ่มเกินไปที่จะทำให้เป็นอัตโนมัติ แต่ถ้าคุณอยากลองเป็นแขกของฉัน

ตรงข้าม_สี()

เปลี่ยนสีเขียวเป็นสีน้ำเงิน สีแดงเป็นสีส้ม สีขาวเป็นสีเหลือง และในทางกลับกัน ตอนนี้ฉันคิดดูแล้ว นี่อาจเป็นคำสั่ง แต่บรรทัดหนึ่งของคณิตศาสตร์และ 3 ifs ก็ใช้ได้เช่นกัน

Apply_color()

หมุนลูกบาศก์ตามสีด้านหน้าและด้านซ้าย หรือสีด้านบน โดยพื้นฐานแล้วจะมีคำสั่ง if จำนวนมากที่มีการเคลื่อนไหวแบบฮาร์ดโค้ด แต่นั่นก็เพียงพอแล้ว

run_alg()