zhenyan121/SporeBG-Conid
1
0
Fork 0
mirror of https://github.com/zhenyan121/SporeBG-Conid.git synced 2026-04-10 06:14:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add place piece function

Browse Source
This commit is contained in:
zhenyan121
2025-11-27 21:24:10 +08:00
parent e4c8325d33
commit c6a0f3b735
8 changed files with 155 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/core/Board.cpp
View File

@@ -11,16 +11,39 @@ Board::Board(int rows, int cols) :
Board::~Board() { Board::~Board() {
} }
//将二维坐标转化成一维坐标
const int Board::getIndex(int row, int col) { const int Board::getIndex(int row, int col) {
return row * m_cols + col; return row * m_cols + col;
} }
void Board::placePieceAt(int row, int col, PlayerID ID) {
int index = getIndex(row, col);
m_grid[index] = std::make_unique<Piece>(ID);
//创建方向数组
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
std::vector<int> existingNeighbors; //记录附近的同色邻居
for (int i = 0; i < 4; i++) {
int nx = row + dx[i];
int ny = col + dy[i];
int pos = getIndex(nx, ny);
//添加邻居
if (m_grid[pos] != nullptr && Rule::canConnect(m_grid[index]->getPieceOwner(), m_grid[pos]->getPieceOwner())) {
existingNeighbors.push_back(pos);
}
}
// 调用componet处理一片的添加和连接操作
m_component->addPiece(index, existingNeighbors);
}
bool Board::initialize() { bool Board::initialize() {
m_grid[getIndex(0, 0)] = std::make_unique<Piece>(PlayerID::P1); placePieceAt(0, 0, PlayerID::P1);
m_grid[getIndex(0, 2)] = std::make_unique<Piece>(PlayerID::P1); placePieceAt(0 ,2, PlayerID::P1);
m_grid[getIndex(6, 6)] = std::make_unique<Piece>(PlayerID::P2); placePieceAt(6, 6, PlayerID::P2);
m_grid[getIndex(5, 5)] = std::make_unique<Piece>(PlayerID::P2); placePieceAt(5, 5, PlayerID::P2);
} }

4
src/core/Board.h
View File

@@ -1,6 +1,7 @@
#pragma once #pragma once
#include "Piece.h" #include "Piece.h"
#include "ComponentManager.h" #include "ComponentManager.h"
#include "Rule.h"
#include <memory> #include <memory>
#include <vector> #include <vector>
// 用 (row, col) 表示坐标，0-based // 用 (row, col) 表示坐标，0-based
@@ -17,6 +18,7 @@ class Board {
private: private:
//使用一维数组表示棋盘 //使用一维数组表示棋盘
std::vector<std::unique_ptr<Piece>> m_grid; std::vector<std::unique_ptr<Piece>> m_grid;
// 连接片管理
std::unique_ptr<ComponentManager> m_component; std::unique_ptr<ComponentManager> m_component;
const int m_rows; const int m_rows;
const int m_cols; const int m_cols;
@@ -26,4 +28,6 @@ public:
const int getIndex(int row, int col); const int getIndex(int row, int col);
std::unique_ptr<Piece>& at(int row, int col); std::unique_ptr<Piece>& at(int row, int col);
bool initialize(); bool initialize();
// 放置棋子
void placePieceAt(int row, int col, PlayerID ID);
}; };

143
src/core/ComponentManager.cpp
View File

@@ -1,29 +1,44 @@
#include "ComponentManager.h" #include "ComponentManager.h"
ComponentManager::ComponentManager(int numPieces) ComponentManager::ComponentManager(int maxPossiblePieces)
: m_totalPieces(numPieces) { : m_maxPossiblePieces(maxPossiblePieces) {
//初始化数组大小 ROWS * COLS //初始化数组大小 ROWS * COLS
m_parent.resize(numPieces); m_parent.resize(maxPossiblePieces, -1); // -1表示无棋子
m_rank.resize(numPieces, 0); m_rank.resize(maxPossiblePieces, 0);
m_adjacentList.resize(numPieces); m_adjacentList.resize(maxPossiblePieces);
//初始化每个棋子为独立组件
for (int i = 0; i < numPieces; i++) {
m_parent[i] = i;
m_componentPieces[i] = {i}; //每个组件初始包含一个棋子
m_pieceToComponent[i] = i; //棋子指向的组件
}
} }
int ComponentManager::find(int pieceId) { void ComponentManager::addPiece(int PieceID, const std::vector<int>& adjacentPiece) {
if (m_parent[pieceId] != pieceId) { if (PieceID < 0 || PieceID >= m_maxPossiblePieces) return;
m_parent[pieceId] = find(m_parent[pieceId]); if (m_parent[PieceID] == -1) return; // 已存在
m_parent[PieceID] = PieceID;
m_rank[PieceID] = PieceID;
m_componentPieces[PieceID] = {PieceID};
m_pieceToComponent[PieceID] = PieceID;
for (int neighbor : adjacentPiece) {
if (neighbor < 0 || neighbor >= m_maxPossiblePieces || m_parent[neighbor] == -1)
continue; // 邻居无效或不存在
// 合并连通组件（unite 会自动处理是否已在同一组件）
unite(PieceID, neighbor);
addConnection(PieceID, neighbor);
} }
return m_parent[pieceId];
} }
void ComponentManager::unite(int pieceId1, int pieceId2) { int ComponentManager::find(int pieceID) {
int root1 = find(pieceId1); if (m_parent[pieceID] != pieceID) {
int root2 = find(pieceId2); m_parent[pieceID] = find(m_parent[pieceID]);
}
return m_parent[pieceID];
}
void ComponentManager::unite(int pieceID1, int pieceID2) {
int root1 = find(pieceID1);
int root2 = find(pieceID2);
if (root1 == root2) { if (root1 == root2) {
return; return;
@@ -46,71 +61,71 @@ void ComponentManager::unite(int pieceId1, int pieceId2) {
m_pieceToComponent[piece] = root1; m_pieceToComponent[piece] = root1;
} }
} }
addConnection(pieceId1, pieceId2); addConnection(pieceID1, pieceID2);
} }
void ComponentManager::addConnection(int pieceId1, int pieceId2) { void ComponentManager::addConnection(int pieceID1, int pieceID2) {
//将元素放入邻接表 //将元素放入邻接表
m_adjacentList[pieceId1].insert(pieceId2); m_adjacentList[pieceID1].insert(pieceID2);
m_adjacentList[pieceId2].insert(pieceId1); m_adjacentList[pieceID2].insert(pieceID1);
} }
bool ComponentManager::disconnectFromNeighbor(int pieceId, int neighborId){ bool ComponentManager::disconnectFromNeighbor(int pieceID, int neighborID){
// 检查是否真的相连 // 检查是否真的相连
if (!areDirectlyConnected(pieceId, neighborId)) { if (!areDirectlyConnected(pieceID, neighborID)) {
return false; return false;
} }
// 从邻接表中移除连接 // 从邻接表中移除连接
m_adjacentList[pieceId].erase(neighborId); m_adjacentList[pieceID].erase(neighborID);
m_adjacentList[neighborId].erase(pieceId); m_adjacentList[neighborID].erase(pieceID);
// 重新计算连通性 // 重新计算连通性
recomputeComponentsAfterDisconnection(pieceId); recomputeComponentsAfterDisconnection(pieceID);
return true; return true;
} }
bool ComponentManager::disconnectFromComponent(int pieceId) { bool ComponentManager::disconnectFromComponent(int pieceID) {
int oldComponentId = find(pieceId); int oldComponentID = find(pieceID);
if (oldComponentId == -1) return false; if (oldComponentID == -1) return false;
// 记录所有直接连接 // 记录所有直接连接
auto neighbors = m_adjacentList[pieceId]; auto neighbors = m_adjacentList[pieceID];
// 断开所有连接 // 断开所有连接
for (int neighborId : neighbors) { for (int neighborID : neighbors) {
m_adjacentList[pieceId].erase(neighborId); m_adjacentList[pieceID].erase(neighborID);
m_adjacentList[neighborId].erase(pieceId); m_adjacentList[neighborID].erase(pieceID);
} }
// 将被断开的棋子设为独立组件 // 将被断开的棋子设为独立组件
m_parent[pieceId] = pieceId; m_parent[pieceID] = pieceID;
m_rank[pieceId] = 0; m_rank[pieceID] = 0;
m_componentPieces[pieceId] = {pieceId}; m_componentPieces[pieceID] = {pieceID};
m_pieceToComponent[pieceId] = pieceId; m_pieceToComponent[pieceID] = pieceID;
// 如果原组件还有其他棋子，需要重新计算连通性 // 如果原组件还有其他棋子，需要重新计算连通性
if (!neighbors.empty()) { if (!neighbors.empty()) {
recomputeComponentsAfterDisconnection(pieceId); recomputeComponentsAfterDisconnection(pieceID);
} }
return true; return true;
} }
void ComponentManager::recomputeComponentsAfterDisconnection(int disconnectedPiece) { void ComponentManager::recomputeComponentsAfterDisconnection(int disconnectedPiece) {
int oldComponentId = find(disconnectedPiece); int oldComponentID = find(disconnectedPiece);
if (oldComponentId == -1 || m_componentPieces[disconnectedPiece].size() <= 1) { if (oldComponentID == -1 || m_componentPieces[disconnectedPiece].size() <= 1) {
return; return;
} }
// 获取原组件中除断开棋子外的所有棋子 // 获取原组件中除断开棋子外的所有棋子
std::unordered_set<int> remainingPieces = m_componentPieces[oldComponentId]; std::unordered_set<int> remainingPieces = m_componentPieces[oldComponentID];
remainingPieces.erase(disconnectedPiece); remainingPieces.erase(disconnectedPiece);
//处理组件分裂 //处理组件分裂
handleComponentSplit(oldComponentId, remainingPieces); handleComponentSplit(oldComponentID, remainingPieces);
} }
void ComponentManager::handleComponentSplit(int oldComponentId, const std:: unordered_set<int>& remainingPieces ) { void ComponentManager::handleComponentSplit(int oldComponentID, const std:: unordered_set<int>& remainingPieces ) {
std::unordered_set<int> visited; std::unordered_set<int> visited;
std::vector<std::unordered_set<int>> newComponents; std::vector<std::unordered_set<int>> newComponents;
@@ -128,7 +143,7 @@ void ComponentManager::handleComponentSplit(int oldComponentId, const std:: unor
newComponents.push_back(connectedRegion); newComponents.push_back(connectedRegion);
} }
// 删除原组件 // 删除原组件
m_componentPieces.erase(oldComponentId); m_componentPieces.erase(oldComponentID);
// 为每个新连通区域创建组件 // 为每个新连通区域创建组件
for (const auto& region : newComponents) { for (const auto& region : newComponents) {
@@ -181,52 +196,52 @@ int ComponentManager::createNewComponent(int rootPiece) {
return rootPiece; return rootPiece;
} }
void ComponentManager::selectComponentByPiece(int pieceId) { void ComponentManager::selectComponentByPiece(int pieceID) {
m_selectedComponentId = find(pieceId); m_selectedComponentID = find(pieceID);
} }
const std::unordered_set<int>& ComponentManager::getSelectedComponent() const { const std::unordered_set<int>& ComponentManager::getSelectedComponent() const {
static std::unordered_set<int> emptySet; static std::unordered_set<int> emptySet;
if (m_selectedComponentId == -1 || if (m_selectedComponentID == -1 ||
m_componentPieces.find(m_selectedComponentId) == m_componentPieces.end()) { m_componentPieces.find(m_selectedComponentID) == m_componentPieces.end()) {
return emptySet; return emptySet;
} }
return m_componentPieces.at(m_selectedComponentId); return m_componentPieces.at(m_selectedComponentID);
} }
int ComponentManager::getComponentId(int pieceId) const { int ComponentManager::getComponentID(int pieceID) const {
auto it = m_pieceToComponent.find(pieceId); auto it = m_pieceToComponent.find(pieceID);
return (it != m_pieceToComponent.end()) ? it->second : -1; return (it != m_pieceToComponent.end()) ? it->second : -1;
} }
const std::unordered_set<int>& ComponentManager::getPiecesInComponent(int componentId) const { const std::unordered_set<int>& ComponentManager::getPiecesInComponent(int componentID) const {
static std::unordered_set<int> emptySet; static std::unordered_set<int> emptySet;
auto it = m_componentPieces.find(componentId); auto it = m_componentPieces.find(componentID);
return (it != m_componentPieces.end()) ? it->second : emptySet; return (it != m_componentPieces.end()) ? it->second : emptySet;
} }
bool ComponentManager::areConnected(int pieceId1, int pieceId2) { bool ComponentManager::areConnected(int pieceID1, int pieceID2) {
return find(pieceId1) == find(pieceId2); return find(pieceID1) == find(pieceID2);
} }
const std::unordered_set<int>& ComponentManager::getPieceConnections(int pieceId) const { const std::unordered_set<int>& ComponentManager::getPieceConnections(int pieceID) const {
static std::unordered_set<int> emptySet; static std::unordered_set<int> emptySet;
if (pieceId < 0 || pieceId >= m_totalPieces) return emptySet; if (pieceID < 0 || pieceID >= m_maxPossiblePieces) return emptySet;
return m_adjacentList[pieceId]; return m_adjacentList[pieceID];
} }
bool ComponentManager::areDirectlyConnected(int pieceId1, int pieceId2) const { bool ComponentManager::areDirectlyConnected(int pieceID1, int pieceID2) const {
if (pieceId1 < 0 || pieceId1 >= m_totalPieces || if (pieceID1 < 0 || pieceID1 >= m_maxPossiblePieces ||
pieceId2 < 0 || pieceId2 >= m_totalPieces) { pieceID2 < 0 || pieceID2 >= m_maxPossiblePieces) {
return false; return false;
} }
return m_adjacentList[pieceId1].find(pieceId2) != m_adjacentList[pieceId1].end(); return m_adjacentList[pieceID1].find(pieceID2) != m_adjacentList[pieceID1].end();
} }
void ComponentManager::clearSelection() { void ComponentManager::clearSelection() {
m_selectedComponentId = -1; m_selectedComponentID = -1;
} }
std:: unordered_map<int, std::unordered_set<int>> ComponentManager::getAllComponents() const { std:: unordered_map<int, std::unordered_set<int>> ComponentManager::getAllComponents() const {

32
src/core/ComponentManager.h
View File

@@ -18,14 +18,14 @@ private:
// 棋子ID到组件ID的映射 // 棋子ID到组件ID的映射
std::unordered_map<int, int> m_pieceToComponent; std::unordered_map<int, int> m_pieceToComponent;
// 当前选中的组件ID // 当前选中的组件ID
int m_selectedComponentId = -1; int m_selectedComponentID = -1;
// 总棋子数 // 总棋子数
int m_totalPieces; int m_maxPossiblePieces;
// 重新计算连通性（断开后调用） // 重新计算连通性（断开后调用）
void recomputeComponentsAfterDisconnection(int disconnectedPiece); void recomputeComponentsAfterDisconnection(int disconnectedPiece);
// 处理组件分裂 // 处理组件分裂
void handleComponentSplit(int oldComponentId, const std::unordered_set<int>& affectedPieces); void handleComponentSplit(int oldComponentID, const std::unordered_set<int>& affectedPieces);
// 使用BFS查找连通区域 // 使用BFS查找连通区域
std::unordered_set<int> bfsConnectedRegion(int startPiece, const std::unordered_set<int>& afftedPieces); std::unordered_set<int> bfsConnectedRegion(int startPiece, const std::unordered_set<int>& afftedPieces);
@@ -35,31 +35,33 @@ private:
public: public:
// 构造函数：初始化指定数量的棋子 // 构造函数：初始化指定数量的棋子
explicit ComponentManager(int numPieces); explicit ComponentManager(int maxPossiblePieces);
//添加棋子
void addPiece(int PieceID, const std::vector<int>& adjacentPiece);
// 查找操作（带路径压缩） // 查找操作（带路径压缩）
int find(int pieceId); int find(int pieceID);
// 合并两个棋子所在的组件（按秩合并） // 合并两个棋子所在的组件（按秩合并）
void unite(int pieceId1, int pieceId2); void unite(int pieceID1, int pieceID2);
// 连接两个组件 // 连接两个组件
void addConnection(int pieceId1, int pieceId2); void addConnection(int pieceID1, int pieceID2);
// 断开棋子与指定邻居的连接 // 断开棋子与指定邻居的连接
bool disconnectFromNeighbor(int pieceId, int neighborId); bool disconnectFromNeighbor(int pieceID, int neighborID);
// 将棋子完全从当前组件断开，成为独立组件 // 将棋子完全从当前组件断开，成为独立组件
bool disconnectFromComponent(int pieceId); bool disconnectFromComponent(int pieceID);
// 通过棋子选择整个连通片 // 通过棋子选择整个连通片
void selectComponentByPiece(int pieceId); void selectComponentByPiece(int pieceID);
// 获取当前选中的组件中的所有棋子 // 获取当前选中的组件中的所有棋子
const std::unordered_set<int>& getSelectedComponent() const; const std::unordered_set<int>& getSelectedComponent() const;
// 获取棋子所属的组件ID // 获取棋子所属的组件ID
int getComponentId(int pieceId) const; int getComponentID(int pieceID) const;
// 获取组件内所有棋子 // 获取组件内所有棋子
const std::unordered_set<int>& getPiecesInComponent(int pieceId) const; const std::unordered_set<int>& getPiecesInComponent(int pieceID) const;
// 检查两个棋子是否在同一个组件中 // 检查两个棋子是否在同一个组件中
bool areConnected(int pieceId1, int pieceId2); bool areConnected(int pieceID1, int pieceID2);
// 获取棋子的所有直接连接 // 获取棋子的所有直接连接
const std::unordered_set<int>& getPieceConnections(int pieceId) const; const std::unordered_set<int>& getPieceConnections(int pieceID) const;
// 检查两个棋子是否直接相连 // 检查两个棋子是否直接相连
bool areDirectlyConnected(int pieceId1, int pieceId2) const; bool areDirectlyConnected(int pieceID1, int pieceID2) const;
// 清除选中状态 // 清除选中状态
void clearSelection(); void clearSelection();

6
src/core/GameTypes.h Normal file
View File

@@ -0,0 +1,6 @@
#pragma once
// 这里存储游戏的各种状态
enum class PlayerID {
P1,
P2
};

6
src/core/Piece.h
View File

@@ -1,9 +1,5 @@
#pragma once #pragma once
#include "GameTypes.h"
enum class PlayerID {
P1,
P2
};
class Piece { class Piece {

10
src/core/Rule.cpp
View File

@@ -0,0 +1,10 @@
#include "Rule.h"
bool Rule::canConnect(const PlayerID a, const PlayerID b) {
if (a == b) {
return true;
}
return false;
}

9
src/core/Rule.h
View File

@@ -1 +1,10 @@
#pragma once #pragma once
#include "GameTypes.h"
class Rule {
public:
static bool canConnect(const PlayerID a, PlayerID b);
};