working title: Swan

Makefile

 # Makefile generated by smake.
 
-PROJNAME = cpplat
+PROJNAME = swan
 PROJTYPE = exe
 
 SRCS = src/Body.cc src/Chunk.cc src/Game.cc src/main.cc src/Player.cc src/WorldPlane.cc

Smakefile

-PROJNAME = cpplat
+PROJNAME = swan
 PKGS = sfml-all
 LDFLAGS += -lstdc++

idea.md

-# Game Idea
+# Game Idea: Swan
 
+* Working title: Swan (maybe the final name should be 'Project: Swan'?)
 * 2D tile-based platformer-esque game
 * Circuit network shit
 * Move along a third axis, the Z axis

src/Body.cc

 #include "Body.h"
 
+namespace Swan {
+
 void Body::friction(float coef) {
 	force_ += -vel_ * coef;
 }
 	pos_ += vel_ * dt;
 	force_ = { 0, 0 };
 }
+
+}

src/Body.h

 
 #include "common.h"
 
+namespace Swan {
+
 class Body {
 public:
 	Vec2 force_ = { 0, 0 };
 	void outline(Win &win);
 	void update(float dt);
 };
+
+}

src/Chunk.cc

 
 #include <string.h>
 
+namespace Swan {
+
 void Chunk::clear() {
 	memset(tiles_, 0, sizeof(tiles_));
 }
 
 void Chunk::draw(Win &win) {
 }
+
+}

src/Chunk.h

 #include "common.h"
 #include "Tile.h"
 
+namespace Swan {
+
 class Chunk {
 public:
 	int x_;
 	void clear();
 	void draw(Win &win);
 };
+
+}

src/Game.cc

 #include "Game.h"
 
+namespace Swan {
+
 void Game::registerTile(std::string &name, Tile &tile) {
 	Tile::TileID id = registered_tiles_.size();
 	registered_tiles_.push_back(tile);
 	for (WorldPlane *plane: planes_)
 		plane->tick();
 }
+
+}

src/Game.h

 #include "Player.h"
 #include "Tile.h"
 
+namespace Swan {
+
 class Game {
 public:
 	Player *player_;
 	void update(float dt);
 	void tick();
 };
+
+}

src/Player.cc

 #include "Player.h"
 
+namespace Swan {
+
+const float Player::force = 600;
+const float Player::friction = 100;
+const float Player::mass = 80;
+const Vec2 Player::size = Vec2(1, 2);
+
 using Keyboard = sf::Keyboard;
 
 void Player::draw(Win &win) {
 
 void Player::update(float dt) {
 	if (Keyboard::isKeyPressed(Keyboard::W) || Keyboard::isKeyPressed(Keyboard::Up))
-		body_.force_.y -= force;
+		body_.force_ += Vec2(0, -force);
 	if (Keyboard::isKeyPressed(Keyboard::S) || Keyboard::isKeyPressed(Keyboard::Down))
-		body_.force_.y += force;
+		body_.force_ += Vec2(0, force);
 	if (Keyboard::isKeyPressed(Keyboard::A) || Keyboard::isKeyPressed(Keyboard::Left))
-		body_.force_.x -= force;
+		body_.force_ += Vec2(-force, 0);
 	if (Keyboard::isKeyPressed(Keyboard::D) || Keyboard::isKeyPressed(Keyboard::Right))
-		body_.force_.x += force;
+		body_.force_ += Vec2(force, 0);
 
 	body_.friction(friction);
 	body_.gravity();
 	body_.update(dt);
 }
+
+}

src/Player.h

 #pragma once
 
-#include <SFML/Graphics.hpp>
-
 #include "common.h"
 #include "Body.h"
 
+namespace Swan {
+
 class Player {
 public:
 	Player(Vec2 pos):
-		body_(pos, Vec2(width, height), mass) {}
+		body_(pos, size, mass) {}
 
 	void draw(Win &win);
 	void update(float dt);
 
 private:
-	static constexpr float force = 600;
-	static constexpr float friction = 100;
-	static constexpr float mass = 80;
-	static constexpr float width = 1;
-	static constexpr float height = 2;
+	static const float force;
+	static const float friction;
+	static const float mass;
+	static const Vec2 size;
 
 	Body body_;
 };
+
+}

src/Tile.h

 
 #include <stdint.h>
 
+namespace Swan {
+
 class Tile {
 public:
 	using TileID = uint16_t;
 
 	Tile(std::string name);
 };
+
+}

src/WorldPlane.cc

 #include "WorldPlane.h"
 
+namespace Swan {
+
 void WorldPlane::draw(Win &win) {
 }
 
 
 void WorldPlane::tick() {
 }
+
+}

src/WorldPlane.h

 #include "common.h"
 #include "Chunk.h"
 
+namespace Swan {
+
 class WorldPlane {
 public:
 	std::vector<Chunk> chunks_;
 	void update(float dt);
 	void tick();
 };
+
+}

src/common.h

 #include <SFML/System/Vector2.hpp>
 #include <SFML/Graphics.hpp>
 
-#define UNIT_SIZE 12.0
-#define TICK_RATE 20
-#define CHUNK_HEIGHT 32
-#define CHUNK_WIDTH 32
+namespace Swan {
+
+static constexpr float UNIT_SIZE = 12;
+static constexpr int TICK_RATE = 20;
+static constexpr int CHUNK_HEIGHT = 32;
+static constexpr int CHUNK_WIDTH = 32;
 
 class Vec2: public sf::Vector2<float> {
 public:
 		window_.draw(drawable, transform_);
 	}
 };
+
+}

src/main.cc

 #include "Player.h"
 #include "Game.h"
 
-double getTime() {
+using namespace Swan;
+
+static double getTime() {
 	struct timespec ts;
 	clock_gettime(CLOCK_MONOTONIC, &ts);
 	return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0;
 }
 
 template<typename T>
-void draw_ents(std::vector<T> ents) {
+static void draw_ents(std::vector<T> ents) {
 	for (auto &ent: ents)
 		ent.draw();
 }