379 lines
9.8 KiB
Go
379 lines
9.8 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
|
|
rl "github.com/gen2brain/raylib-go/raylib"
|
|
)
|
|
|
|
const (
|
|
MapWidth = 100
|
|
MapHeight = 100
|
|
TileSize = 32
|
|
TileHeight = 2.0
|
|
)
|
|
|
|
var (
|
|
cameraDistance = float32(20.0)
|
|
cameraYaw = float32(145.0)
|
|
cameraPitch = float32(90.0)
|
|
)
|
|
|
|
type Tile struct {
|
|
X, Y int
|
|
Height float32
|
|
Walkable bool
|
|
}
|
|
|
|
type Player struct {
|
|
PosActual rl.Vector3
|
|
PosTile Tile
|
|
TargetPath []Tile
|
|
Speed float32
|
|
}
|
|
|
|
// Initialize the map with some height data
|
|
func InitMap() [][]Tile {
|
|
mapGrid := make([][]Tile, MapWidth)
|
|
for x := 0; x < MapWidth; x++ {
|
|
mapGrid[x] = make([]Tile, MapHeight)
|
|
for y := 0; y < MapHeight; y++ {
|
|
mapGrid[x][y] = Tile{
|
|
X: x,
|
|
Y: y,
|
|
Height: 1.0 + float32(x%5), //float32((x + y) % 10), // Example height
|
|
Walkable: true, // Set to false for obstacles
|
|
}
|
|
}
|
|
}
|
|
return mapGrid
|
|
}
|
|
|
|
func DrawMap(mapGrid [][]Tile) {
|
|
for x := 0; x < MapWidth; x++ {
|
|
for y := 0; y < MapHeight; y++ {
|
|
tile := mapGrid[x][y]
|
|
// Interpolate height between adjacent tiles for a smoother landscape
|
|
height := tile.Height
|
|
if x > 0 {
|
|
height += mapGrid[x-1][y].Height
|
|
}
|
|
if y > 0 {
|
|
height += mapGrid[x][y-1].Height
|
|
}
|
|
if x > 0 && y > 0 {
|
|
height += mapGrid[x-1][y-1].Height
|
|
}
|
|
height /= 4.0
|
|
// Draw each tile as a 3D cube based on its height
|
|
tilePos := rl.Vector3{
|
|
X: float32(x * TileSize), // X-axis for horizontal position
|
|
Y: height * TileHeight, // Y-axis for height (Z in 3D is Y here)
|
|
Z: float32(y * TileSize), // Z-axis for depth (Y in 3D is Z here)
|
|
}
|
|
color := rl.Color{R: uint8(height * 25), G: 100, B: 100, A: 64}
|
|
rl.DrawCube(tilePos, TileSize, TileHeight, TileSize, color) // Draw a cube representing the tile
|
|
}
|
|
}
|
|
}
|
|
|
|
func DrawPlayer(player Player, mapGrid [][]Tile) {
|
|
// Get current tile height
|
|
currentTile := mapGrid[player.PosTile.X][player.PosTile.Y]
|
|
// Draw player cube with height from the map
|
|
playerPos := rl.Vector3{
|
|
X: float32(player.PosTile.X * TileSize),
|
|
Y: currentTile.Height * TileHeight,
|
|
Z: float32(player.PosTile.Y * TileSize),
|
|
}
|
|
rl.DrawCube(playerPos, 16, 16, 16, rl.Green) // Draw player cube
|
|
}
|
|
|
|
func GetTileAtMouse(mapGrid [][]Tile, camera *rl.Camera3D) (Tile, bool) {
|
|
if !rl.IsMouseButtonPressed(rl.MouseLeftButton) {
|
|
return Tile{}, false
|
|
}
|
|
mouse := rl.GetMousePosition()
|
|
|
|
// Unproject mouse coordinates to 3D ray
|
|
var ray rl.Ray = rl.GetMouseRay(mouse, *camera)
|
|
|
|
// Calculate the distance from the camera to the ray's intersection with the ground plane (Y=0)
|
|
dist := -ray.Position.Y / ray.Direction.Y
|
|
|
|
// Calculate the intersection point
|
|
intersection := rl.NewVector3(
|
|
ray.Position.X+ray.Direction.X*dist,
|
|
ray.Position.Y+ray.Direction.Y*dist,
|
|
ray.Position.Z+ray.Direction.Z*dist,
|
|
)
|
|
|
|
// Convert the intersection point to tile coordinates
|
|
tileX := int(intersection.X / float32(TileSize))
|
|
tileY := int(intersection.Z / float32(TileSize))
|
|
|
|
if tileX >= 0 && tileX < MapWidth && tileY >= 0 && tileY < MapHeight {
|
|
fmt.Println("Clicked:", tileX, tileY)
|
|
return mapGrid[tileX][tileY], true
|
|
}
|
|
return Tile{}, false
|
|
}
|
|
|
|
func UpdatePlayer(player *Player, deltaTime float32, mapGrid [][]Tile, camera *rl.Camera) {
|
|
if len(player.TargetPath) > 0 {
|
|
targetTile := player.TargetPath[0]
|
|
|
|
// Calculate the direction vector to the target
|
|
direction := rl.Vector3{
|
|
X: float32(targetTile.X*TileSize) - player.PosActual.X,
|
|
Y: float32(targetTile.Y*TileSize) - player.PosActual.Y,
|
|
}
|
|
|
|
// Normalize the direction vector to get smooth movement
|
|
dist := float32(math.Sqrt(float64(direction.X*direction.X + direction.Y*direction.Y)))
|
|
if dist > 0 {
|
|
direction.X /= dist
|
|
direction.Y /= dist
|
|
}
|
|
|
|
// Move towards the target
|
|
newPosX := player.PosActual.X + direction.X*player.Speed*deltaTime
|
|
newPosY := player.PosActual.Y + direction.Y*player.Speed*deltaTime
|
|
|
|
// Check if the player is moving into a non-walkable tile
|
|
if !mapGrid[int(newPosX)/TileSize][int(newPosY)/TileSize].Walkable {
|
|
return
|
|
}
|
|
|
|
// Update player's position
|
|
player.PosActual.X = newPosX
|
|
player.PosActual.Y = newPosY
|
|
|
|
// Check if the player reached the target tile
|
|
if dist < 1.0 {
|
|
player.PosActual.X = float32(targetTile.X * TileSize)
|
|
player.PosActual.Y = float32(targetTile.Y * TileSize)
|
|
player.PosTile = targetTile // Update the player's tile position
|
|
player.TargetPath = player.TargetPath[1:] // Move to the next tile in the path
|
|
}
|
|
}
|
|
}
|
|
|
|
func HandleInput(player *Player, mapGrid [][]Tile, camera *rl.Camera) {
|
|
clickedTile, clicked := GetTileAtMouse(mapGrid, camera)
|
|
if clicked {
|
|
path := FindPath(mapGrid, mapGrid[player.PosTile.X][player.PosTile.Y], clickedTile)
|
|
if path != nil {
|
|
// Exclude the first tile (current position)
|
|
if len(path) > 1 {
|
|
player.TargetPath = path[1:]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
rl.InitWindow(800, 600, "RuneScape-like Game")
|
|
defer rl.CloseWindow()
|
|
|
|
frameCnt := 0
|
|
|
|
mapGrid := InitMap()
|
|
|
|
player := Player{
|
|
PosTile: Tile{X: 10, Y: 10},
|
|
PosActual: rl.Vector3{X: float32(10 * TileSize), Y: float32(10 * TileSize), Z: float32(mapGrid[10][10].Height /* * TileHeight */)},
|
|
Speed: 100.0, // pixels per second
|
|
}
|
|
|
|
// Initialize 3D camera
|
|
camera := rl.Camera3D{
|
|
Position: rl.NewVector3(player.PosActual.X+cameraDistance, player.PosActual.Y+cameraDistance, player.PosActual.Z+cameraDistance),
|
|
Target: player.PosActual, // The point the camera looks at (player)
|
|
Up: rl.NewVector3(0, 1, 0), // Camera up vector (y-axis is up)
|
|
Fovy: 45.0, // Field of view
|
|
Projection: rl.CameraPerspective, // Perspective camera mode
|
|
}
|
|
|
|
camera.Target = player.PosActual
|
|
|
|
rl.SetTargetFPS(60)
|
|
|
|
for !rl.WindowShouldClose() {
|
|
deltaTime := rl.GetFrameTime()
|
|
|
|
frameCnt++
|
|
frameCnt %= 60
|
|
|
|
// Update camera based on mouse wheel
|
|
wheelMove := rl.GetMouseWheelMove()
|
|
if wheelMove != 0 {
|
|
cameraDistance += -wheelMove * 5
|
|
if cameraDistance < 1 {
|
|
cameraDistance = 1
|
|
} else if cameraDistance > 100 {
|
|
cameraDistance = 100
|
|
}
|
|
}
|
|
|
|
// Update camera based on arrow keys (camera orbits player)
|
|
if rl.IsKeyDown(rl.KeyRight) {
|
|
cameraYaw -= 60 * deltaTime // Rotate right
|
|
}
|
|
if rl.IsKeyDown(rl.KeyLeft) {
|
|
cameraYaw += 60 * deltaTime // Rotate left
|
|
}
|
|
if rl.IsKeyDown(rl.KeyUp) {
|
|
cameraPitch += 60 * deltaTime // Tilt up
|
|
}
|
|
if rl.IsKeyDown(rl.KeyDown) {
|
|
cameraPitch -= 60 * deltaTime // Tilt down
|
|
}
|
|
|
|
// Constrain camera pitch to avoid flipping
|
|
if cameraPitch > 85.0 {
|
|
cameraPitch = 85.0
|
|
} else if cameraPitch < -10.0 {
|
|
cameraPitch = -10.0
|
|
}
|
|
HandleInput(&player, mapGrid, &camera)
|
|
UpdatePlayer(&player, deltaTime, mapGrid, &camera)
|
|
|
|
camera.Target = player.PosActual
|
|
// Convert spherical coordinates to cartesian to calculate the camera's position
|
|
camera.Position.X = player.PosActual.X + cameraDistance*float32(math.Cos(float64(cameraPitch)*math.Pi/180.0))*float32(math.Sin(float64(cameraYaw)*math.Pi/180.0))
|
|
camera.Position.Y = player.PosActual.Y + cameraDistance*float32(math.Sin(float64(cameraPitch)*math.Pi/180.0))
|
|
camera.Position.Z = player.PosActual.Z + cameraDistance*float32(math.Cos(float64(cameraPitch)*math.Pi/180.0))*float32(math.Cos(float64(cameraYaw)*math.Pi/180.0))
|
|
|
|
// Begin rendering
|
|
rl.BeginDrawing()
|
|
rl.ClearBackground(rl.RayWhite)
|
|
rl.BeginMode3D(camera)
|
|
|
|
// Draw map and player
|
|
DrawMap(mapGrid)
|
|
DrawPlayer(player, mapGrid)
|
|
|
|
rl.EndMode3D()
|
|
rl.EndDrawing()
|
|
|
|
if frameCnt == 0 {
|
|
fmt.Printf("Player Pos: %v, Camera Pos: %v\n", player.PosActual, camera.Position)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// pathfinding
|
|
type Node struct {
|
|
Tile Tile
|
|
Parent *Node
|
|
G, H, F float32
|
|
}
|
|
|
|
func FindPath(mapGrid [][]Tile, start, end Tile) []Tile {
|
|
openList := []*Node{}
|
|
closedList := make(map[[2]int]bool)
|
|
|
|
startNode := &Node{Tile: start, G: 0, H: heuristic(start, end)}
|
|
startNode.F = startNode.G + startNode.H
|
|
openList = append(openList, startNode)
|
|
|
|
for len(openList) > 0 {
|
|
// Find node with lowest F
|
|
current := openList[0]
|
|
currentIndex := 0
|
|
for i, node := range openList {
|
|
if node.F < current.F {
|
|
current = node
|
|
currentIndex = i
|
|
}
|
|
}
|
|
|
|
// Move current to closed list
|
|
openList = append(openList[:currentIndex], openList[currentIndex+1:]...)
|
|
closedList[[2]int{current.Tile.X, current.Tile.Y}] = true
|
|
|
|
// Check if reached the end
|
|
if current.Tile.X == end.X && current.Tile.Y == end.Y {
|
|
path := []Tile{}
|
|
node := current
|
|
for node != nil {
|
|
path = append([]Tile{node.Tile}, path...)
|
|
node = node.Parent
|
|
}
|
|
fmt.Printf("Path found: %v\n", path)
|
|
return path
|
|
}
|
|
|
|
// Generate neighbors
|
|
neighbors := GetNeighbors(mapGrid, current.Tile)
|
|
for _, neighbor := range neighbors {
|
|
if !neighbor.Walkable || closedList[[2]int{neighbor.X, neighbor.Y}] {
|
|
continue
|
|
}
|
|
|
|
tentativeG := current.G + distance(current.Tile, neighbor)
|
|
inOpen := false
|
|
var existingNode *Node
|
|
for _, node := range openList {
|
|
if node.Tile.X == neighbor.X && node.Tile.Y == neighbor.Y {
|
|
existingNode = node
|
|
inOpen = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !inOpen || tentativeG < existingNode.G {
|
|
newNode := &Node{
|
|
Tile: neighbor,
|
|
Parent: current,
|
|
G: tentativeG,
|
|
H: heuristic(neighbor, end),
|
|
}
|
|
newNode.F = newNode.G + newNode.H
|
|
if !inOpen {
|
|
openList = append(openList, newNode)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// No path found
|
|
fmt.Println("No path found")
|
|
return nil
|
|
}
|
|
|
|
func heuristic(a, b Tile) float32 {
|
|
return float32(abs(a.X-b.X) + abs(a.Y-b.Y))
|
|
}
|
|
|
|
func distance(a, b Tile) float32 {
|
|
_ = a
|
|
_ = b
|
|
return 1.0 //uniform cost for now
|
|
}
|
|
|
|
func GetNeighbors(mapGrid [][]Tile, tile Tile) []Tile {
|
|
directions := [][2]int{
|
|
{1, 0}, {-1, 0}, {0, 1}, {0, -1},
|
|
{1, 1}, {-1, -1}, {1, -1}, {-1, 1},
|
|
}
|
|
neighbors := []Tile{}
|
|
for _, dir := range directions {
|
|
nx, ny := tile.X+dir[0], tile.Y+dir[1]
|
|
if nx >= 0 && nx < MapWidth && ny >= 0 && ny < MapHeight {
|
|
neighbors = append(neighbors, mapGrid[nx][ny])
|
|
}
|
|
}
|
|
return neighbors
|
|
}
|
|
|
|
func abs(x int) int {
|
|
if x < 0 {
|
|
return -x
|
|
}
|
|
return x
|
|
}
|