aboutsummaryrefslogtreecommitdiff
path: root/src/main.odin
blob: 9a6c09a197b80bc43eb626aed6bfb036f140c05f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package demonchime

// import "core:math"
// import "core:math/rand"
// import "core:time"

import "base:runtime"

import "core:log"
import "core:fmt"

import rl "vendor:raylib"

import "draw"
import "phys"

Vec2 :: [2]f32

Rect :: struct {
  start: Vec2,
  size: Vec2,
}

state: struct {
  player: Player,
  platform_list: Entity_List(Platform),
}

init :: proc() {
  init_keybinds()

  draw.init()

  init_player(&state.player)

  make_platform(Rect{
    start = {50, 50},
    size = {64, 20}
  })

  i := f32(20)
  for i < draw.SCREEN_WIDTH - 20 - 64 {
    make_platform(Rect{
      start = {i, 340},
      size = {64, 20}
    })
    i += 65
  }

  make_platform(Rect{
    start = {160, 320},
    size = {20, 20}
  })
  make_platform(Rect{
    start = {240, 280},
    size = {40, 20}
  })
  make_platform(Rect{
    start = {260, 260},
    size = {20, 20}
  })
  make_platform(Rect{
    start = {300, 220},
    size = {40, 20}
  })

  make_platform(Rect{
    start = {240, 180},
    size = {40, 20}
  })

  make_platform(Rect{
    start = {200, 140},
    size = {40, 20}
  })

  make_platform(Rect{
    start = {180, 100},
    size = {20, 20}
  })
  
  make_platform(Rect{
    start = {140, 100},
    size = {16, 16}
  })
}

frame :: proc() {
  update_player(&state.player, rl.GetFrameTime())

  draw.new_frame()

  fps_text := fmt.caprintf(
    "FPS: %v", rl.GetFPS(),
    allocator = context.temp_allocator,
  )
  rl.DrawText(fps_text, 5, 5, 8, rl.GREEN)

  draw_platforms()
  draw_player(state.player)

  draw.end_frame()
}

cleanup :: proc() {
  delete_entity_list(state.platform_list)
}

main :: proc() {
  logger := log.create_console_logger()
  context.logger = logger
  defer log.destroy_console_logger(logger)

  rl.InitWindow(480 * 2, 360 * 2, "Demonchime")

  rl.SetWindowState({.WINDOW_RESIZABLE})

  init()

  for !rl.WindowShouldClose() {
    frame()

    free_all(context.temp_allocator)
  }

  cleanup()
}