Background

Myewasii

A final-year Information Security student at HCMUTE with a broad foundation in networking and data, I am passionately pursuing a career in development. As a highly adaptable fast-learner with strong English communication skills, I am eager to join a team where I can actively contribute while acquiring new skills and mindsets.

  • I'm Capable Of: Web Design-Development, Programming, Problem Solving
Contact Me
About image

My game.

Orange Cat Shooter

Orange Cat Shooter

2D Topdown Shooter Game

A charismatic 2D top-down shooter featuring an orange cat protagonist with smooth animations, cannon combat mechanics, and enemy AI systems.

🎮 Character System

Fluid idle, walk, run, and dash animations with state-based animation controller

Idle Walk Run

🔫 Combat Mechanics

Mouse-aimed cannon system with projectile physics, cooldown management, and sprite flipping

Aiming Shooting

👾 Enemy AI

Autonomous dark enemies with independent movement systems and animation states

Unity C# 2D Animation Physics AI
View Code

Game Arts.

This is where I show you my arts, it's amateur but I enjoy drawing stuff so, here it is.
Warning: Aseprite not sponsor these arts!

The Catbish

The Catbish

Mr.Owl

Mr.Owl

The Heart

The Heart

Self-portrait

Self-portrait

Other Projects.

Spring Boot Backend Database Design

Spring Boot Backend API

Secure JWT Authentication & RESTful APIs

A robust Spring Boot backend application with RESTful APIs, JWT authentication, and modular architecture designed for scalability and maintainability.

🔐 Security Features

JWT authentication, Spring Security, role-based access control, password encryption with BCrypt

🏗️ Architecture

Clean modular structure with Controller → Service → Repository pattern, DTO mapping with MapStruct

Spring Boot Java JWT MySQL Docker
View Code
UTE Football Booking System

UTE Football

Football Pitch Booking & Management System

A comprehensive football pitch booking system with user management, booking system, and admin dashboard. Currently live at app.myewsx.online

🎯 Core Features

Pitch booking system, user management, booking history, payment integration

🌐 Live Deployment

Successfully deployed and accessible at app.myewsx.online with real users

Spring Boot Thymeleaf MySQL PostgreSQL Bootstrap
View Code Live Demo
AI Crypto Agents

AI Crypto Agents

Autogen-based Cryptocurrency Data Analysis

AI agents system using Microsoft Autogen framework to analyze cryptocurrency data from CSV files, providing insights and automated trading strategies.

🤖 AI Agents

Multi-agent system with specialized roles for data analysis and strategy development

📊 Data Processing

Automated CSV data reading, cryptocurrency market analysis, pattern recognition

Python Autogen Pandas NumPy Machine Learning
View Code

Resume.

Lương Tất Thuận

Lương Tất Thuận

Myewasii

Through both my academic training and self-learning, I have developed a solid foundation in programming, Object-Oriented Programming (OOP), and software design patterns. Although my major focuses on hacking and system security, giving me strong knowledge in networking and cybersecurity, I have also spent my personal time to game arts game development — currently working solo on my own project, Orange Shooter.

I can say that I have devoted quite a lot of time to full-stack web development because I enjoy designing a system from start to finish. The process of upgrading and optimizing systems always excites me while working.

I am familiar with using source control tools and databases, creating CI/CD pipelines, and performing deployment and orchestration with Kubernetes, because I believe I should understand how every stage of a system works — not only to serve the user experience but also to support my team effectively.

I believe that I have a strong ability to learn and adapt to new environments, as otherwise I wouldn't have been able to work across so many different fields such as hacking, networking, game development, and web development.

Security Mindset
Game Dev Passion
Full-Stack Developer
CI/CD Experience
Fun GIF

Technical Skills

Programming Concepts

Object-Oriented Programming (OOP) Design Patterns Algorithm Implementation Physics Problem Solving

Game Development

C# Programming Unity Engine 2D Topdown Platformers Animation Systems Gameplay Mechanics 2D Art & Pixel Art

Web Development

Spring Boot Spring Web MVC Spring Security Spring REST API CSS & HTML

DevOps & Tools

Source Control (Git) CI/CD Pipelines Kubernetes Docker Deployment Database Management

Additional Skills

Python (Beginner) CSV File Handling AI Agent Development Networking & Security Testing & Debugging

Soft Skills

Analytical Thinking

Capable of analyzing game mechanics, identifying problems, and designing effective solutions

Creative Implementation

Ability to create 2D pixel characters and animations for game projects

English Communication

Effective English communication (reading, writing, speaking) with broad knowledge of Western game industry and culture

Fast Learning & Adaptation

Proven ability to work across diverse fields including security, networking, game development, and web development

Team Collaboration

Understanding of full system lifecycle to effectively support team members and projects

Contact Background

Let's talk!

I'm always open to discussing web development, new opportunities, or just having a friendly chat about technology and creativity.

Email luongtatthuan@gmail.com
Phone +84 033 590 9874
GitHub github.com/Mewasii

Get in Touch

Game Development Documentation

Orange Cat Shooter

Unity Game Design & Implementation

Prefab System
  • Prefab Implementation: Created modular prefabs for characters, enemies, butllet, and environmental objects
  • Asset Organization: Structured prefab hierarchy for maintainable game architecture
2D Top-Down Movement System
  • Character Controller: Developed smooth 2D top-down movement with acceleration and deceleration
  • Input Handling: Implemented responsive keyboard and mouse input systems
  • Collision Detection: Integrated 2D colliders and rigidbody physics for accurate movement
  • Animation States: Created state machine for idle, walk, run animations with smooth transitions
Camera System
  • Cinemachine Virtual Camera: Configured dynamic camera following with smooth damping
Combat & Mechanics
Dodge Roll System
  • Dash Ability: Implemented directional dashin
  • Invincibility Frames: Added temporary invulnerability during dodge animations
  • Animation Integration: Synchronized dodge animations with movement mechanics
  • Input Buffering: Created responsive input system for seamless dodge execution
2D Shooting System
  • Mouse-Aimed Cannons: Developed precise mouse-based aiming and shooting mechanics
  • Projectile Physics: Implemented bullet trajectory, speed, and collision detection
  • Weapon Cooldown: Added firing rate limitations
  • Sprite Flipping: Automated character sprite orientation based on aiming direction
AI & Enemy Systems
Pathfinding Implementation
  • A* Algorithm: Integrated A* pathfinding for intelligent enemy navigation
  • Navigation Meshes: Set up 2D navigation for complex level layouts
  • Obstacle Avoidance: Implemented dynamic obstacle detection and path recalculation
Enemy AI Behavior
  • State Machines: Created AI states (Idle, Patrol, Chase, Attack) with smooth transitions
  • Movement Patterns: Programmed various enemy movement behaviors and patrol routes
  • Target Detection: Implemented player detection systems with vision cones and range checks
Combat AI
  • AI Coordination: Implemented basic enemy group behaviors and formations
Game Systems & UI
Health Bar System
  • Dynamic Health UI: Created responsive health bar that updates in real-time
  • Damage Feedback: Implemented visual and feedback for damage taken
Technical Implementation Details
Animation & Visuals
  • 2D Sprite Animation: Created frame-by-frame animations for all character states
  • Animation Controllers: Built complex animator controllers with blend trees
  • Visual Effects: Implemented particle systems for explosions, trails, and abilities
Physics & Collisions
  • 2D Physics: Utilized Unity's 2D physics engine for realistic interactions
  • Collision Layers: Organized collision matrix for efficient object interactions
  • Trigger Systems: Created interactive triggers for gameplay events

Spring Boot Backend Documentation

Spring Boot Backend with Spring Security & JWT Authentication

A production-ready backend application with secure authentication and modular architecture

Project Overview

A Spring Boot backend application with RESTful APIs, authentication, and modular architecture designed for scalability, maintainability, and ease of integration with frontend or mobile clients.

Key Objectives
  • Authentication & Authorization: Secure user management with JWT and OAuth2
  • Database Integration: Spring Data JPA with relational databases (MySQL/SQLServer)
  • Modular Architecture: Controller → Service → Repository pattern
  • Testing Support: Comprehensive testing with JUnit and Mockito
  • Docker-Ready: Easy deployment across different environments
🚀 Features
Object Mapping: MapStruct for clean DTO/entity conversions
Lombok: Reduced boilerplate code
Password Encryption: BCrypt for secure password hashing
Spring Security: Role-based access control
Fine-grained Authorization: Endpoint-level permissions
Validation: Hibernate Validator + custom annotations
Token Management: Logout & Refresh Token mechanism
Exception Handling: Global error handling with unique error codes
📁 Project Structure
src/main/java/
├───config/          # Application & security configurations
├───controller/      # REST controllers (API endpoints)
├───dto/            # Data Transfer Objects
│   ├───request/    # Incoming request payloads
│   └───response/   # Outgoing response payloads
├───entity/         # JPA entities (database models)
├───enums/          # Enum definitions
├───exception/      # Custom exceptions & error handling
├───mapper/         # MapStruct mappers
├───repository/     # Spring Data JPA repositories
└───service/        # Business logic layer
    └───impl/       # Service implementations
🗄️ Database Design
Database Schema

Complete database schema showing entity relationships and constraints

Key Entities
  • User: Core user entity with authentication details
  • Role: Role-based access control definitions
  • Permission: Fine-grained access permissions
  • Token: JWT token management for authentication
🔄 Mapper Layer (MapStruct)

The Mapper layer plays a crucial role in converting data between API layer (DTOs) and domain layer (Entities).

Mapper Layer Flow

Data flow through the mapper layer

Benefits
  • Separation of Concerns: Clean separation between internal models and external API contracts
  • Security: Sensitive fields (password hashes) remain hidden from clients
  • Efficiency: Reduced boilerplate through automatic DTO ↔ Entity mapping
  • Maintainability: Consistent and maintainable code structure
Data Flow
1
Incoming Request
Controller receives RequestDTO
→
2
Mapping
MapStruct converts RequestDTO → Entity
→
3
Business Logic
Service processes Entity + JWT data
→
4
Outgoing Response
MapStruct converts Entity → ResponseDTO
🔐 JWT Authentication & Security

Secure authentication system using Spring Security with JWT (JSON Web Token) for stateless authentication.

JWT Authentication Flow

JWT authentication flow diagram

Authentication Flow
  1. Login: User provides username and password
  2. Validation: Server validates credentials against stored data
  3. Token Generation: JWT token generated upon successful authentication
  4. Client Storage: Token stored client-side (localStorage/cookies)
  5. API Requests: Token included in Authorization header
  6. Token Validation: Server validates token for protected resources
JWT Benefits
  • Stateless: No server-side sessions required
  • Lightweight: Efficient for distributed systems
  • Expiration Support: Built-in token expiration
  • Claims-based: Flexible user information encoding
Security Configuration
  • SecurityConfig.java: Defines endpoint security requirements
  • JWT Filters: Intercept and validate incoming requests
  • Role-based Access: Fine-grained permission control
  • AuthenticationServiceImpl.java: Centralized authentication logic
🌐 API Endpoints
Authentication Endpoints
POST /api/auth/login User login with credentials
POST /api/auth/register Register new user account
POST /api/auth/refresh Refresh JWT token
POST /api/auth/logout Invalidate current token
User Management Endpoints
GET /api/users/profile Get current user profile
PUT /api/users/profile Update user profile
🚀 Deployment & Setup
Prerequisites
  • Java 17 or higher
  • MySQL 8.0+ or SQL Server
  • Maven 3.6+
  • Docker (optional)
Quick Start
# Clone repository
git clone https://github.com/Mewasii/ACS.git

# Configure database in application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/your_database
spring.datasource.username=your_username
spring.datasource.password=your_password

# Build and run
mvn clean install
mvn spring-boot:run
Docker Deployment
# Build Docker image
docker build -t spring-boot-backend .

# Run with Docker Compose
docker-compose up -d
🧪 Testing

Comprehensive test suite ensuring application reliability and security.

Test Structure
  • Unit Tests: Service layer testing with Mockito
  • Integration Tests: API endpoint testing
  • Security Tests: Authentication and authorization testing
  • Repository Tests: Database interaction testing
Running Tests
# Run all tests
mvn test

# Run specific test class
mvn test -Dtest=AuthenticationServiceTest

# Run with coverage report
mvn jacoco:report

AI Crypto Agents Documentation

AI Crypto Trading Agents System

Autogen-based Cryptocurrency Data Analysis & Automated Trading Platform

📊 Project Overview

A comprehensive AI-powered cryptocurrency trading system using Microsoft Autogen framework to analyze market data, generate trading strategies, and execute automated trades with real-time data processing.

Core Capabilities
  • Multi-Agent System: Specialized AI agents for different trading tasks
  • Real-time Data: Live market data from Binance API
  • Technical Analysis: Advanced indicator calculations and chart analysis
  • Backtesting: Historical strategy validation
  • Automated Execution: Strategy-based trade execution
📁 Project Structure
ATM/
main.py (8882 bytes) - Main application entry point
streamlit_app.py (5126 bytes) - Web interface
test.py (3643 bytes) - Testing suite
requirements.txt - Python dependencies
agents/ - AI Agent System
data_calculation_agent.py (9521 bytes) - Data processing agent
historical_data_agent.py (10654 bytes) - Historical data management
indicator_agent.py (5856 bytes) - Technical indicator calculations
strategy_agent.py (6160 bytes) - Trading strategy generation
backtest_agent.py (5790 bytes) - Strategy backtesting
chart_agent.py (12490 bytes) - Chart analysis and visualization
binance_agent.py (3251 bytes) - Binance API integration
websocket_agent.py (2718 bytes) - Real-time data streaming
data/ - Data Management
raw/ - Raw market data
BTCUSDT_1h.csv - Hourly Bitcoin data
BTCUSDT_1m.csv - Minute Bitcoin data
processed/ - Processed data
heikinashi/ - Heikin-Ashi processed data
indicator/ - Technical indicator data
strategy/ - Strategy output data
strategies/ - Trading Strategies
base_strategy.py - Abstract strategy class
ema_crossover.py - EMA crossover strategy
strategy_registry.py - Strategy management
utils/ - Utility Functions
config.py - Configuration management
data_processor.py - Data processing utilities
🤖 AI Agents Architecture
Agent System Overview

Data Calculation Agent

Handles complex data processing, indicator calculations, and mathematical operations for trading analysis.

File: 9521 bytes Complexity: High

Historical Data Agent

Manages historical price data, data retrieval, and temporal analysis for backtesting and pattern recognition.

File: 10654 bytes Complexity: High

Indicator Agent

Calculates technical indicators (RSI, MACD, Bollinger Bands) and generates trading signals.

File: 5856 bytes Complexity: Medium

Strategy Agent

Generates and manages trading strategies, position sizing, and risk management rules.

File: 6160 bytes Complexity: High

Backtest Agent

Performs historical strategy testing, performance metrics calculation, and optimization.

File: 5790 bytes Complexity: Medium

Chart Agent

Handles chart analysis, pattern recognition, and visualization of trading data.

File: 12490 bytes Complexity: High
📈 Data Pipeline & Processing
Data Flow Architecture
1
Data Collection

Real-time data from Binance API via WebSocket and REST APIs

→
2
Raw Storage

Store raw market data in CSV format (1m, 1h intervals)

→
3
Data Processing

Calculate indicators, Heikin-Ashi, and technical analysis

→
4
Strategy Application

Apply trading strategies to processed data

→
5
Decision Making

AI agents analyze data and generate trading signals

Data Structure

Raw Data Tier

  • BTCUSDT_1m.csv: 148,497 rows of minute data
  • BTCUSDT_1h.csv: 57,028 rows of hourly data
  • Includes OHLCV data (Open, High, Low, Close, Volume)

Processed Data Tier

  • Heikin-Ashi: Smoothed price representation
  • Indicators: RSI, MACD, Bollinger Bands, etc.
  • Strategy Signals: Buy/Sell signals and positions
💡 Trading Strategies
Current Implementations

EMA Crossover Strategy

File: ema_crossover.py (1207 bytes)

Logic: Uses Exponential Moving Average crossovers to generate buy/sell signals when short-term EMA crosses long-term EMA.

Fast EMA: 12 Slow EMA: 26 Signal EMA: 9
Strategy Framework
  • Base Strategy Class: Abstract class defining strategy interface
  • Strategy Registry: Centralized management of all strategies
  • Modular Design: Easy to add new strategies
  • Parameter Optimization: Support for strategy optimization
⚙️ Technical Implementation
Core Technologies

AI Framework

Microsoft Autogen Multi-Agent Systems

Data Processing

Pandas NumPy TA-Lib

API Integration

Binance API WebSocket REST API

Visualization

Streamlit Matplotlib Plotly
Key Features
  • Real-time Processing: WebSocket integration for live data
  • Modular Architecture: Separated concerns with specialized agents
  • Extensible Design: Easy to add new indicators and strategies
  • Backtesting Engine: Comprehensive historical testing
  • Risk Management: Built-in position sizing and risk controls
🚀 Usage & Deployment
Quick Start
# Clone the repository
git clone https://github.com/Mewasii/ATM.git
cd ATM

# Set up virtual environment
python -m venv venv
venv\Scripts\activate  # Windows
source venv/bin/activate  # Linux/Mac

# Install dependencies
pip install -r requirements.txt

# Run the main application
python main.py

# Or run the Streamlit web interface
streamlit run streamlit_app.py
Configuration
# .env file configuration
BINANCE_API_KEY=your_api_key
BINANCE_SECRET_KEY=your_secret_key
DATA_PATH=./data
LOG_LEVEL=INFO

# Trading parameters
INITIAL_BALANCE=10000
RISK_PER_TRADE=0.02  # 2% risk per trade
MAX_POSITION_SIZE=0.1  # 10% of portfolio
Available Commands
  • python main.py - Start main trading application
  • streamlit run streamlit_app.py - Launch web interface
  • python test.py - Run test suite
  • python checklib.py - Check library dependencies
📊 Performance & Metrics
Backtesting Results
  • Total Return: Strategy performance over test period
  • Sharpe Ratio: Risk-adjusted returns
  • Max Drawdown: Maximum peak-to-trough decline
  • Win Rate: Percentage of profitable trades
  • Profit Factor: Gross profit vs gross loss
Real-time Monitoring
  • Live P&L: Real-time profit and loss tracking
  • Position Management: Active trade monitoring
  • Risk Exposure: Current portfolio risk assessment
  • Signal Quality: Strategy signal performance