Skip to content

Fixes to breaking changes in C3 0.6 -> 0.7: #61

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Fixes to breaking changes in C3 0.6 -> 0.7: #61

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
ad955a3
Fixes to breaking changes in C3 0.6 -> 0.7:
lerno Mar 3, 2025
698697d
More fixes to breaking changes in C3 0.6 -> 0.7:
lerno Mar 13, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions src/client.c3
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,7 +31,7 @@ const uint SPRITE_ANGLES_COUNT = 8;

$exec("build/packer");

def Color = char[<4>];
alias Color = char[<4>];

macro Vector2.angle_fixed(self) => platform::atan2f(self.y, self.x);
// // TODO: math::atan2 is broken. Does not work with sprite_angle_index() properly.
Expand Down Expand Up @@ -880,8 +880,8 @@ fn bool process_message(Message *unknown_message) @extern("process_message") @wa
}

Player me;
def OtherPlayersEntry = Entry(<uint, Player>);
HashMap(<uint, Player>) other_players;
alias OtherPlayersEntry = Entry {uint, Player};
HashMap {uint, Player} other_players = map::ONHEAP {uint, Player};

fn uint players_count() @extern("players_count") @wasm {
return other_players.len() + 1; // +1 including `me`
Expand Down
90 changes: 44 additions & 46 deletions src/common.c3
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@ import std::collections::list;
import std::collections::map;
import std::hash::fnv32a;

def ShortString = char[64];
alias ShortString = char[64];

// WARNING! struct Asset definition must be in sync with the one in common.h
struct Asset {
Expand All @@ -15,7 +15,7 @@ struct Asset {
usz height;
}

def Assets = List(<Asset>);
alias Assets = List {Asset};

const ushort SERVER_PORT = 6970; // WARNING! Has to be in sync with SERVER_PORT in client.mts
const float BOMB_GRAVITY = 10;
Expand All @@ -27,11 +27,11 @@ const float PLAYER_SIZE = 0.5;
const float PLAYER_RADIUS = 0.5;
const float PLAYER_SPEED = 2;

def Vector2 = float[<2>];
def IVector2 = int[<2>];
alias Vector2 = float[<2>];
alias IVector2 = int[<2>];
fn uint IVector2.hash(IVector2 self) => fnv32a::encode(@as_char_view(self));
def Vector3 = float[<3>];
def Vector4 = float[<4>];
alias Vector3 = float[<3>];
alias Vector4 = float[<4>];

fn Vector2 from_polar(float angle, float len) {
return {math::cos(angle)*len, math::sin(angle)*len};
Expand Down Expand Up @@ -69,7 +69,7 @@ struct Message @packed {
/// Scenea //////////////////////////////

struct Scene {
HashMap(<IVector2, bool>) walls;
HashMap {IVector2, bool} walls;
}

Scene scene;
Expand All @@ -85,6 +85,7 @@ fn void load_default_scene() {
};
usz width = default_walls[0].len;
usz height = default_walls.len;
scene.walls.init(mem);
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
if (default_walls[y][x]) {
Expand All @@ -95,10 +96,7 @@ fn void load_default_scene() {
}

fn bool Scene.get_tile(&scene, Vector2 p) {
if (try tile = scene.walls.get((IVector2)math::floor(p))) {
return tile;
}
return false;
return scene.walls.get((IVector2)math::floor(p))) ?? false;
}

fn bool Scene.can_rectangle_fit_here(&scene, float px, float py, float sx, float sy) {
Expand Down Expand Up @@ -176,9 +174,9 @@ struct ItemSpawned @packed {
float y;
}

def ItemsSpawnedBatchMessage = BatchMessage(<ItemSpawned, MessageKind.ITEM_SPAWNED>);
def verify_items_spawned_batch_message = msg::batch::verify(<ItemSpawned, MessageKind.ITEM_SPAWNED>);
def alloc_items_spawned_batch_message = msg::batch::alloc(<ItemSpawned, MessageKind.ITEM_SPAWNED>);
alias ItemsSpawnedBatchMessage = BatchMessage {ItemSpawned, MessageKind.ITEM_SPAWNED};
alias verify_items_spawned_batch_message = msg::batch::verify {ItemSpawned, MessageKind.ITEM_SPAWNED};
alias alloc_items_spawned_batch_message = msg::batch::alloc {ItemSpawned, MessageKind.ITEM_SPAWNED};

fn ItemsSpawnedBatchMessage* reconstruct_state_of_items(Item[] *items) {
usz itemsCount = 0;
Expand All @@ -202,9 +200,9 @@ fn ItemsSpawnedBatchMessage* reconstruct_state_of_items(Item[] *items) {
return message;
}

def ItemsCollectedBatchMessage = BatchMessage(<int, MessageKind.ITEM_COLLECTED>);
def verify_items_collected_batch_message = msg::batch::verify(<int, MessageKind.ITEM_COLLECTED>);
def alloc_items_collected_batch_message = msg::batch::alloc(<int, MessageKind.ITEM_COLLECTED>);
alias ItemsCollectedBatchMessage = BatchMessage {int, MessageKind.ITEM_COLLECTED};
alias verify_items_collected_batch_message = msg::batch::verify {int, MessageKind.ITEM_COLLECTED};
alias alloc_items_collected_batch_message = msg::batch::alloc {int, MessageKind.ITEM_COLLECTED};

/// Bombs //////////////////////////////

Expand All @@ -216,7 +214,7 @@ struct Bomb {
float lifetime;
}

def Bombs = Bomb[20];
alias Bombs = Bomb[20];
Bombs bombs;

fn int throw_bomb(Vector2 position, float direction, Bombs *bombs) {
Expand Down Expand Up @@ -278,9 +276,9 @@ struct BombSpawned @packed {
float lifetime;
}

def BombsSpawnedBatchMessage = BatchMessage(<BombSpawned, MessageKind.BOMB_SPAWNED>);
def verify_bombs_spawned_batch_message = msg::batch::verify(<BombSpawned, MessageKind.BOMB_SPAWNED>);
def alloc_bombs_spawned_batch_message = msg::batch::alloc(<BombSpawned, MessageKind.BOMB_SPAWNED>);
alias BombsSpawnedBatchMessage = BatchMessage {BombSpawned, MessageKind.BOMB_SPAWNED};
alias verify_bombs_spawned_batch_message = msg::batch::verify {BombSpawned, MessageKind.BOMB_SPAWNED};
alias alloc_bombs_spawned_batch_message = msg::batch::alloc {BombSpawned, MessageKind.BOMB_SPAWNED};

struct BombExploded @packed {
uint bombIndex;
Expand All @@ -289,9 +287,9 @@ struct BombExploded @packed {
float z;
}

def BombsExplodedBatchMessage = BatchMessage(<BombExploded, MessageKind.BOMB_EXPLODED>);
def verify_bombs_exploded_batch_message = msg::batch::verify(<BombExploded, MessageKind.BOMB_EXPLODED>);
def alloc_bombs_exploded_batch_message = msg::batch::alloc(<BombExploded, MessageKind.BOMB_EXPLODED>);
alias BombsExplodedBatchMessage = BatchMessage {BombExploded, MessageKind.BOMB_EXPLODED};
alias verify_bombs_exploded_batch_message = msg::batch::verify {BombExploded, MessageKind.BOMB_EXPLODED};
alias alloc_bombs_exploded_batch_message = msg::batch::alloc {BombExploded, MessageKind.BOMB_EXPLODED};

/// Player //////////////////////////////

Expand Down Expand Up @@ -322,17 +320,17 @@ struct PlayerStruct @packed {
char moving;
}

def PlayersJoinedBatchMessage = BatchMessage(<PlayerStruct, MessageKind.PLAYER_JOINED>);
def verify_players_joined_batch_message = msg::batch::verify(<PlayerStruct, MessageKind.PLAYER_JOINED>);
def alloc_players_joined_batch_message = msg::batch::alloc(<PlayerStruct, MessageKind.PLAYER_JOINED>);
alias PlayersJoinedBatchMessage = BatchMessage {PlayerStruct, MessageKind.PLAYER_JOINED};
alias verify_players_joined_batch_message = msg::batch::verify {PlayerStruct, MessageKind.PLAYER_JOINED};
alias alloc_players_joined_batch_message = msg::batch::alloc {PlayerStruct, MessageKind.PLAYER_JOINED};

def PlayersLeftBatchMessage = BatchMessage(<uint, MessageKind.PLAYER_LEFT>);
def verify_players_left_batch_message = msg::batch::verify(<uint, MessageKind.PLAYER_LEFT>);
def alloc_players_left_batch_message = msg::batch::alloc(<uint, MessageKind.PLAYER_LEFT>);
alias PlayersLeftBatchMessage = BatchMessage {uint, MessageKind.PLAYER_LEFT};
alias verify_players_left_batch_message = msg::batch::verify {uint, MessageKind.PLAYER_LEFT};
alias alloc_players_left_batch_message = msg::batch::alloc {uint, MessageKind.PLAYER_LEFT};

def PlayersMovingBatchMessage = BatchMessage(<PlayerStruct, MessageKind.PLAYER_MOVING>);
def verify_players_moving_batch_message = msg::batch::verify(<PlayerStruct, MessageKind.PLAYER_MOVING>);
def alloc_players_moving_batch_message = msg::batch::alloc(<PlayerStruct, MessageKind.PLAYER_MOVING>);
alias PlayersMovingBatchMessage = BatchMessage {PlayerStruct, MessageKind.PLAYER_MOVING};
alias verify_players_moving_batch_message = msg::batch::verify {PlayerStruct, MessageKind.PLAYER_MOVING};
alias alloc_players_moving_batch_message = msg::batch::alloc {PlayerStruct, MessageKind.PLAYER_MOVING};

struct HelloPlayer @packed {
uint id;
Expand All @@ -342,27 +340,27 @@ struct HelloPlayer @packed {
char hue;
}

def HelloMessage = SingleMessage(<HelloPlayer, MessageKind.HELLO>);
def verify_hello_message = msg::single::verify(<HelloPlayer, MessageKind.HELLO>);
alias HelloMessage = SingleMessage {HelloPlayer, MessageKind.HELLO};
alias verify_hello_message = msg::single::verify {HelloPlayer, MessageKind.HELLO};

def PongMessage = SingleMessage(<uint, MessageKind.PONG>);
def verify_pong_message = msg::single::verify(<uint, MessageKind.PONG>);
alias PongMessage = SingleMessage {uint, MessageKind.PONG};
alias verify_pong_message = msg::single::verify {uint, MessageKind.PONG};

struct AmmaMoving @packed {
Moving direction;
char start;
}

def AmmaMovingMessage = SingleMessage(<AmmaMoving, MessageKind.AMMA_MOVING>);
def verify_amma_moving_message = msg::single::verify(<AmmaMoving, MessageKind.AMMA_MOVING>);
alias AmmaMovingMessage = SingleMessage {AmmaMoving, MessageKind.AMMA_MOVING};
alias verify_amma_moving_message = msg::single::verify {AmmaMoving, MessageKind.AMMA_MOVING};

// TODO: EmptyMessage does not need Payload type, but since passing void is forbidden in C3, we must provide something.
// Providing uint in here is a completely arbitrary decision. Investigate how such things should be made properly.
def AmmaThrowingMessage = EmptyMessage(<MessageKind.AMMA_THROWING>);
def verify_amma_throwing_message = msg::empty::verify(<MessageKind.AMMA_THROWING>);
alias AmmaThrowingMessage = EmptyMessage {MessageKind.AMMA_THROWING};
alias verify_amma_throwing_message = msg::empty::verify {MessageKind.AMMA_THROWING};

def PingMessage = SingleMessage(<uint, MessageKind.PING>);
def verify_ping_message = msg::single::verify(<uint, MessageKind.PING>);
alias PingMessage = SingleMessage {uint, MessageKind.PING};
alias verify_ping_message = msg::single::verify {uint, MessageKind.PING};

fn void update_player(Player *player, Scene *scene, float delta_time) {
Vector2 control_velocity = {0, 0};
Expand Down Expand Up @@ -402,7 +400,7 @@ fn void* allocate_temporary_buffer(usz size) @extern("allocate_temporary_buffer"
return mem::tcalloc(size);
}

module common::msg::empty(<KIND>);
module common::msg::empty {KIND};

struct EmptyMessage @packed {
uint byte_length;
Expand All @@ -416,7 +414,7 @@ fn EmptyMessage*! verify(Message *message) {
return empty_message;
}

module common::msg::single(<Payload, KIND>);
module common::msg::single {Payload, KIND};

struct SingleMessage @packed {
uint byte_length;
Expand All @@ -431,7 +429,7 @@ fn SingleMessage*! verify(Message *message) {
return single_message;
}

module common::msg::batch(<Payload, KIND>);
module common::msg::batch {Payload, KIND};

struct BatchMessage @packed {
uint byte_length;
Expand Down
2 changes: 1 addition & 1 deletion src/cws/coroutine.c3
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@
module coroutine;
import std::net;

def CoroutineFn = fn void(void*);
alias CoroutineFn = fn void(void*);

extern fn void sleep_read(int fd) @extern("coroutine_sleep_read");
extern fn void sleep_write(int fd) @extern("coroutine_sleep_write");
Expand Down
10 changes: 5 additions & 5 deletions src/cws/cws.c3
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,11 +24,11 @@ const CwsError ERROR_CLIENT_HANDSHAKE_DUPLICATE_ACCEPT = -12;
const CwsError ERROR_CLIENT_HANDSHAKE_NO_ACCEPT = -13;
const CwsError ERROR_CUSTOM = -100;

def CwsSocketReadFn = fn int(void* data, void* buffer, usz len);
def CwsSocketWriteFn = fn int(void* data, void* buffer, usz len);
def CwsSocketPeekFn = fn int(void* data, void* buffer, usz len);
def CwsSocketShutdownFn = fn int(void* data, CwsShutdownHow how);
def CwsSocketCloseFn = fn int(void *data);
alias CwsSocketReadFn = fn int(void* data, void* buffer, usz len);
alias CwsSocketWriteFn = fn int(void* data, void* buffer, usz len);
alias CwsSocketPeekFn = fn int(void* data, void* buffer, usz len);
alias CwsSocketShutdownFn = fn int(void* data, CwsShutdownHow how);
alias CwsSocketCloseFn = fn int(void *data);

struct CwsSocket {
void* data;
Expand Down
28 changes: 14 additions & 14 deletions src/server.c3
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,14 +31,14 @@ fn void send_message_and_update_stats(uint player_id, void* message) {

/// Connection Limits //////////////////////////////

def ShortString = char[64];
alias ShortString = char[64];
macro uint ShortString.hash(self) => fnv32a::encode(&self);
def ConnectionLimitEntry = Entry(<ShortString, uint>);
HashMap(<ShortString, uint>) connection_limits;
alias ConnectionLimitEntry = Entry {ShortString, uint};
HashMap {ShortString, uint} connection_limits = map::ONHEAP {ShortString, uint};

/// Items //////////////////////////////

List(<usz>) collected_items;
List {usz} collected_items = list::ONHEAP {usz};

fn void collect_items_by_player(Player player, Item[] *items) {
foreach (index, &item: *items) {
Expand All @@ -60,7 +60,7 @@ fn ItemsCollectedBatchMessage *collected_items_as_batch_message(Item[]* items) {

/// Bombs //////////////////////////////

List(<usz>) thrown_bombs;
List {usz} thrown_bombs = list::ONHEAP {usz};

fn void throw_bomb_on_server_side(uint player_id, Bombs *bombs) {
if (try player = players.get(player_id)) {
Expand All @@ -87,7 +87,7 @@ fn BombsSpawnedBatchMessage *thrown_bombs_as_batch_message(Bombs *bombs) {
return message;
}

List(<usz>) exploded_bombs;
List {usz} exploded_bombs = list::ONHEAP {usz};

fn void update_bombs_on_server_side(Scene *scene, float delta_time, Bombs *bombs) {
foreach (bombIndex, &bomb: *bombs) {
Expand Down Expand Up @@ -122,14 +122,14 @@ struct PlayerOnServer {
ShortString remote_address;
}

def PlayerOnServerEntry = Entry(<uint, PlayerOnServer>);
HashMap(<uint, PlayerOnServer>) players;
alias PlayerOnServerEntry = Entry {uint, PlayerOnServer};
HashMap {uint, PlayerOnServer} players;

def PlayerIdsEntry = Entry(<uint, bool>);
HashMap(<uint, bool>) joined_ids;
HashMap(<uint, bool>) left_ids;
def PingEntry = Entry(<uint, uint>);
HashMap(<uint, uint>) ping_ids;
alias PlayerIdsEntry = Entry {uint, bool};
HashMap {uint, bool} joined_ids;
HashMap {uint, bool} left_ids;
alias PingEntry = Entry {uint, uint};
HashMap {uint, uint>) ping_ids;

fn bool register_new_player(uint id, ShortString* remote_address) @extern("register_new_player") @wasm {
if (players.len() >= SERVER_TOTAL_LIMIT) {
Expand Down Expand Up @@ -478,7 +478,7 @@ fn uint tick() @extern("tick") @wasm {

// Entry ///////////////////////////////

HashMap(<uint, Cws>) connections;
HashMap {uint, Cws>) connections = map::ONHEAP {uint, Cws};;
uint idCounter = 0;

extern fn CwsSocket cws_socket_from_fd(int fd) @extern("cws_socket_from_fd");
Expand Down