Card Game Sim

Step 1: Scrape Card Data with Python ✓

The first phase of the project involves using Python and Selenium to scrape card data from the Union Arena Card List page. This step includes:

Applying the "HUNTER X HUNTER" filter to the card list. However, you can change it to any of the titles available.
Clicking on the first visible card to open its details.
Extracting card details such as Card Name, Card Number, Image URL, BP, Effect, Trigger, and AP Cost from the iframe using BeautifulSoup.
Iterating through additional cards by clicking the Next button.
Storing the scraped data into a CSV file.

Note: If you want to run the code yourself, simply change the chrome_driver_path variable in the code to match the location of ChromeDriver on your computer.

Code Excerpt



# Ask user for the number of cards to scrape
num_cards_to_scrape = int(input("Enter number of cards to scrape: "))
cards_data = []

def scrape_current_card():
  # Wait for the detail iframe to load and switch into it
  iframe = WebDriverWait(driver, 10).until(
      EC.presence_of_element_located((By.CSS_SELECTOR, ".fancybox-iframe"))
  )
  driver.switch_to.frame(iframe)
  time.sleep(1)
  html = driver.page_source
  soup = BeautifulSoup(html, "html.parser")
  # Extract details...
  card_name = soup.find("h2", class_="cardNameCol").get_text(strip=True)
  card_number = soup.select_one("div.cardNumCol span.cardNumData").get_text(strip=True)
  img_dd = soup.find("dd", class_="cardDataImgCol")
  img_tag = img_dd.find("img") if img_dd else None
  image_url = ("https://www.unionarena-tcg.com" + img_tag.get("src")) if img_tag and img_tag.get("src").startswith("/") else None
  bp = soup.select_one("dl.cardDataCol.bpData dd.cardDataContents").get_text(strip=True)
  effect_dd = soup.select_one("dl.cardDataCol.effectData dd.cardDataContents")
  if effect_dd:
      effect_img = effect_dd.find("img")
      effect_label = effect_img.get("alt", "").strip() if effect_img else ""
      effect_text = effect_dd.get_text(strip=True).replace(effect_label, "").strip()
      effect = effect_label + " - " + effect_text if effect_label else effect_text
  else:
      effect = "N/A"
  trigger = soup.select_one("dl.cardDataCol.triggerData dd.cardDataContents").get_text(strip=True)
  ap_cost = soup.select_one("dl.cardDataCol.apData dd.cardDataContents").get_text(strip=True)
  driver.switch_to.default_content()
  return {
      "Card Name": card_name,
      "Card Number": card_number,
      "Image URL": image_url,
      "BP": bp,
      "Effect": effect,
      "Trigger": trigger,
      "AP Cost": ap_cost
  }

# Click on the first card and scrape its details
first_card_link = WebDriverWait(driver, 10).until(
  EC.element_to_be_clickable((By.CSS_SELECTOR, "li.cardImgCol:not([style*='display: none']) a.modalCardDataOpen"))
)
first_card_link.click()
time.sleep(2)
cards_data.append(scrape_current_card())
print("Scraped card 1.")

# Loop through subsequent cards using the Next button in the modal
for i in range(1, num_cards_to_scrape):
  next_button = WebDriverWait(driver, 10).until(
      EC.element_to_be_clickable((By.CSS_SELECTOR, "div.fancybox-navigation button[data-fancybox-next]"))
  )
  next_button.click()
  time.sleep(2)
  cards_data.append(scrape_current_card())
  print(f"Scraped card {i+1}.")

This code snippet shows the complete Step 1 process. It first applies the filter, then clicks the first card, scrapes its details, and then iterates through the desired number of cards by clicking the Next button.

Step 2: Store Data in PostgreSQL

Once the data is scraped, it will be stored in a PostgreSQL database. The main tasks here include:

Designing an efficient database schema to accommodate various card attributes and relationships.
Using Python libraries like psycopg2 or SQLAlchemy for database interactions.
Ensuring data integrity and optimizing queries for fast retrieval of card information.

A well-designed database is essential for serving data quickly and reliably to the game’s API.

Step 3: Build API Using FastAPI

The next phase focuses on building a RESTful API with FastAPI in Python. This API will:

Retrieve card data and game state from the PostgreSQL database.
Process game moves and update game states in real time.
Expose endpoints for the game UI to query and manipulate data, including authentication and error handling.

FastAPI’s performance and asynchronous support make it an ideal choice for managing real-time game interactions.

Step 4: Develop Game UI and Mechanics in Unity & C#

With the backend in place, the focus shifts to the game interface. This step includes:

Building an engaging and intuitive user interface using Unity.
Implementing game mechanics (e.g., drawing cards, playing moves, animating interactions) in C#.
Integrating the Unity front-end with the FastAPI backend to reflect real-time game data.

This phase transforms raw data and logic into an immersive, interactive game environment.

Step 5: Implement Multiplayer Turn-Based Logic

The final phase is to integrate multiplayer functionality, focusing on turn-based gameplay. This involves:

Designing a server-side architecture to manage multiple players and concurrent game sessions.
Implementing turn-based logic to ensure fair and synchronized gameplay.
Tackling challenges such as latency, synchronization, and conflict resolution in a multiplayer environment.

This step is aims to deliver a seamless multiplayer experience.

Project Overview