What are you asking about memory management? They work pretty much the same. You can allocate memory from OS and you can free memory from OS. What else do you need? There are more advanced concepts like mapping memory (files or no files), changing protection flags (read-only, read-write, read-write-execute, etc..), and more..

mmozeiko
What are you asking about memory management? They work pretty much the same. You can allocate memory from OS and you can free memory from OS. What else do you need? There are more advanced concepts like mapping memory (files or no files), changing protection flags (read-only, read-write, read-write-execute, etc..), and more..

yeah, I was getting crashes but I found out it was just code. I'm not sure but I know where is it and the file causing but I haven't investigated it yet and I can take it out with out it affecting the program. I'll figure it out, thanks.

Btw, I have a list with all the user somebody is following on twitch with a Red dot that indicates the user isn't broadcasting and a green dot if they are. Straight forward but I was thing of having a pop-up window when somebody is broadcasting but I'm not sure if it will be annoying or end up hiding under another window.

I've been away for a little while. Appreciate the new posts and will update the list accordingly. Keep coming back every now and again... interesting news regarding this list is approaching ;)

I'm working on a text editor called "Hale". Currently the editor is in the phase of prototyping. I've used my older prototype as a base, created some time before HH. For that reason, it's currently in Qt/C++ OOP style. As the prototype is getting feature complete, I'm moving the code piece by piece into a non-OOP HH-ish style, also removing dependencies on Qt.

Configuration is where the magic happens. It allows for full customization in a structure that reminds of CSS: it combines selectors and properties (due to recent hates on CSS on twitter, I feel it's important to note, that Hale's system does not allow for any layout changes, and only uses a subset of CSS for defining fonts, colors and paddings). Every entity and it's state of the application is expressed via a scope path. A simple scope path to a plain text document looks like this "app window panel document.text.plain". You can then use scope selector to match scope paths of interest and apply properties to it. Typically you might need a different font for C++ code and a different font for Markdown. In a pseudo-code:



The same mechanism is used to capture events (for example "onSaved"), define your own custom commands, or even specify parsers.

The system also allows for creating modes similar to Vim. Each entity holds a stack of modes that are also present in the scope path. Modes are completely user-defined and function as namespaces. Hale currently only defines commands for "normal" mode. It is important to note, that even if Hale defines commands, it doesn't mean you have to use them. Command has to be mapped to an event, usually to a keyDown, and that mapping is completely in user's hands.

The syntax-highlighting is also implemented using this system. You can not only specify colors and font styles, but you can even define your own commands. For example commands that only apply to comments in your code: document.source.c comment. I use Markdown in comments, so I have Ctrl+B mapped to bold, Ctrl+I mapped to italic, etc (and yes, Hale allows for nesting grammars).

On top of that, I'm currently also experimenting with something I call "brackets". A bracket is a concept similar to projects in IDE's but it's much more lose and flexible. A bracket is essentially a portion of file system tree. The bracket roots are currently detected by special files/directories (for example .git, .svn, .hale, etc.). You can also have nested brackets, and each bracket is then also present in the scope. Typical use is to capture "onSaved" event in my Hale's documentation directory that rebuilds the HTML documentation whenever I change it's Markdown source. For example when I'm editing a documentation file the scope is set to "app window panel bracket.hale bracket.documentation document.text.markdown".

Even though I think this system is extremely powerful, all this stuff is slowly being moved to a separate module you can simply opt-out and only use the core C++ entities (windows, panels, models) for your own system.

I plan to open source Hale when it reaches reasonable stability state. I'm not sure whether that happens before I get rid of Qt dependencies or after.

My blog: http://coh.io/
My twitch: http://twitch.tv/martincohen (archiving broadcasts currently doesn't work, I'm investigating why that is).
My twitter: http://twitter.com/martin_cohen

Hey guys! I'm very happy to see some folks writing text editors inspired by HH - at least they ALL will care about being fast! No Clojure around here, hehe!

I'll be watching Hale closely since, in a previous era, Martin Cohen wrote a very beautiful text editor, and some qualities of that product will probably be on Hale. And I really feel the same as he in his blog posts (see http://coh.io/post/128920102860/games-tools).

(Disclaimer: I actually know nothing about making successful products...)

I said on Twitter that if I could write a text editor in the likes of Sublime/Hale, I'd explore different areas. I would just ignore the hard parts (proper syntax highlighting, code folding..) for now, and do stuff that the existing text editors don't do.

1. I'd add some of your beautiful Disposable game to Hale: gamification in the good sense. Visual feedback, motivation, retro/old-school looks. Try to bring some qualities from games to the editor... Make typing funnier. Vim brings a sense of achievement that people enjoy. Of course, being complex on purpose makes no sense, but making hard things possible... yes. Power to the users.

2. Vim is great when editing a single file, but isn't as effective for projects, even though they cloned Sublime/Textmate Ctrl-T in a plugin... sometimes, the magic breaks.

I'd like to try a new thing in this area: a project view that would actually be a really long buffer consisting of the project files in sequence, with beautiful separators with the filenames. The user could see and reorder the files in a minimap-style sidebar. This new view would make "replace in project" much simpler: you would replace in this big view - which IS the project. Maybe you could toggle between this and regular tab view (but remember that tabs have scalability issues - power Emacs users sometimes have hundreds of buffers open...)

3. Another thing about find & replace: a change this could be presented to the user as a set of changes - a diff - that the user might "accept all", or toggle some of the lines to apply. Also the user shouldn't be punished if he wants to undo or redo that operation.

4. Text-vs-icons: its probably my age, but I can't properly memorize the icons used for actions nowadays. Takes a huge toll on me brain. Again, I'm thinking about Sublime's Search & Replace box. Would be great if there was an option to replace these images with tiny text or abbreviations: "RE, CS, WW" is much easier to memorize than images for toggling "regular expressions, case sensitivity and whole word mode".

5. Fun gamish thing: a pane showing your typing speed vs time, maybe showing the "bursts of productivity". Some kind of "compressing" would be needed since we're mostly idle.

Ideally the users could write those things - like Emacs allows - but leaving the everything-is-text paradigm behind and being allowing one to do proper graphical stuff.

6. Easy building/running: bring some of that Turbo C qualities that Casey talks about into it. Make the edit-compile-run loop fast and fun, give visual feedback.

7. Different fonts for comments vs non-comment code. Just another nice thing some editors have.

8. Track changes: allow me to see previous versions easily (Braid plays with time!), but compress my several hundred "saves" in fewer revisions, by analyzing when and where the edits were made.

Sorry for being so random... I just really enjoy text editors and would love to improve Emacs on some axis. Would love to have a great playground for this ;)

List is updated.

Shorter description for the list:

Hale is an open-source text editor prototyped in Qt/C++ (mostly for historical reasons), about to be rewritten to independent HMH-style code (hopefully mostly live on my stream), when the prototyping is done. Hale uses unique scope-based approach for visual and functional customization, plus a close shell-level integration with the OS. It combines principles from TextMate (Sublime), Emacs and Vim in a single coherent package. It's using Lua/LuaJIT, while still allowing for writing extensions in C++ (either as Lua module, or by directly talking to the Hale's C++ API).




My blog: coh.io
My twitch: twitch.tv/martincohen (archiving broadcasts currently doesn't work, I'm investigating why that is)
My twitter: twitter.com/martin_cohen

Introducing, Sh*t Outa Land - aka SOL

A Faster Than Light (FTL)-inspired roguelike that focuses on running your crew, exploring, and crafting.

You are the captain and your floating vessel is your home in a world where there is no land to be found… or is there?

Project Overview

Language: C
IDE: Vim
Libraries: SDL (for now)
Repository: GitHub
Tools: Tiled, GDB
Game Genres: Roguelike, Survival Sim

Development Goals

-Player-controlled captain of the ship.
-Crew management achieved through a global command system.
-A real-time turn-based action system.
-Maintenance and upgrade system to keep your ship afloat.
-Craft the components needed to maintain and upgrade your ship.
-Discover new components and materials through exploration.
-TBD…

Game Design Goals

-The ship and your crew are your only hope for survival. They are your life.
-Players can enjoy the game through aggressive action or passive exploration.
-Crafting is enjoyable and gives the player a sense of accomplishment.
-Every decision is important and the player must take the time to think them through.
-TBD…

Hello everyone,

The contribution I am currently planning is called Handmade Quake, where I start from nothing (of course) and build the original Quake source code, as it exists (more or less) on GitHub.

I found this source base to be fundamental when I was learning to program games, and I hope to help use this historic and impressive code base to introduce more people to a basic game engine that's only about 40k lines big - not impossible to really wrap your head around!

The code base itself is admittedly messy, and has some gross hacks that were maybe essential in 1996, but definitely don't apply in 2015 (the function to manually page all storage into memory is one of my favorites). However, as a milestone in games and 100% free, plus an online community that still exists today, it seems like a good spot to introduce new game programmers to the world of 3D.

It's currently in the planning phase, but a little over a year ago I started something like this for Quake 2. Sadly, grad school was pretty overwhelming at the time and I only did one video. The idea was definitely good though:

https://www.youtube.com/watch?v=XlEXCTt4ulo

Overall, I'll post more info as I get everything in order, but Handmade Quake should be a great addition for budding game programmers who want to get their feet wet in the 3D world.

CaptainKraft
Introducing, Sh*t Outa Land - aka SOL

A Faster Than Light (FTL)-inspired roguelike that focuses on running your crew, exploring, and crafting.

You are the captain and your floating vessel is your home in a world where there is no land to be found… or is there?

Project Overview

Language: C
IDE: Vim
Libraries: SDL (for now)
Repository: GitHub
Tools: Tiled, GDB
Game Genres: Roguelike, Survival Sim

Development Goals

-Player-controlled captain of the ship.
-Crew management achieved through a global command system.
-A real-time turn-based action system.
-Maintenance and upgrade system to keep your ship afloat.
-Craft the components needed to maintain and upgrade your ship.
-Discover new components and materials through exploration.
-TBD…

Game Design Goals

-The ship and your crew are your only hope for survival. They are your life.
-Players can enjoy the game through aggressive action or passive exploration.
-Crafting is enjoyable and gives the player a sense of accomplishment.
-Every decision is important and the player must take the time to think them through.
-TBD…

Since I started planning and working on this project (slowly, I know), I have refined what I want to accomplish. I explored the idea of starting from scratch similar to Casey and writing my own engine. I will be writing this for Linux first instead of Windows, but the process would be very similar. I have also considered working on a toolkit/framework for making more traditional roguelikes and building it using SDL (like I planned originally for just the game). I've since started leaning more towards the latter.

I enjoyed playing around with a bit of X11 code to get a window up and running and trying to figure out how the hell to use their API, but ultimately I decided to go with SDL. Because I want to focus more on writing good software, and not necessarily just writing a good game, I think I'll be building a tool alongside the game.

Here's an overview of my plane:

-Use the game idea above to motivate progress on a roguelike creation tool
-Create a usable interface for making games with the tool
-Separate the game bits into modules that can be logically separated in the tool for ease of use
-Learn more about interface and usability

Most of my code is written without any users in mind. I write what I need to use and I don't consider if it will ever be used by others. It's time to try something different and make something that (hopefully) people will actually use.

That's all for now. Keep an eye on my website for any updates if you're interested in the project.

So back in around February I made a minesweeper clone in C, being inspired by Handmade Hero. Due to some life stuff and my army service beginning, I didn't have a chance to share it on this forum until now.

How HH inspired me:

Before watching the series I didn't really program in C++, and I was a big fan of OOP but my interest in programming was diminished. Somehow the series rekindled that interest, and I was really surprised that programming in a more data-oriented approach and a lower level was way funner for me that what I was used to do in university!

So after watching like the first 20 episodes of HH, I decided to devote my free time in making something, so I stopped there, and started programming. My goal was to make it look and feel as close as to the original old minesweeper for windows.

I basically used all I learned from HH up to ep.20 to program this, and I only had to work out how to do sprite handling myself, which turned out to be pretty fun.


Controls etc, TL;DR:Try the arrow keys, and the +, -, *.

There are no menus like the original game, but you can control the size of the board with the arrow keys, and add or decrease mines with the + and - keys. Also the * key automatically adds an appropriate number of mines based on the current size. This isn't a very comfortable way of doing this, but I wasn't comfortable with doing a UI for these yet. Also the game doesn't save anything, sorry about that ^^'.


So here it is:

https://www.dropbox.com/s/1xpv26cw9zakng8/Minesweeper_x86.exe?dl=0

Thanks Casey for making programming fun for me again :)

The Veldt



Loosely based off the story by Ray Bradbury, this run based roguelike has you dropped into your own imagination. In the Veldt, your character's perspective comes into fruition as drastically warped and construed horrors, as you go deeper and deeper, the world around you starts to become more and more surreal as you reflect your imagination back into itself by facing it head on.

Twitter

Now that everyone is streaming on twitch, and since twitch has a very slow website, I made this:

It's a little dashboard that lets me see who's streaming at the moment and provides quick links to their latest broadcasts.

You can see it live here: http://asafgartner.github.io/twitch_panel/
And customize the user list by downloading the html here: https://github.com/asafgartner/twitch_panel

Project Name: "Zvuk"

What is it: software drum machine / sampler / sequencer written from scratch.

Blog Announcement: brokenopcode.com

I'll be streaming most days at random times on twitch.tv Note I don't talk during the stream, it's just pure C coding goodness!

There's two streams so far and here's an example of what's been done:

* window creation
* file memory mapping
* modern opengl context creation and function loading without libraries
* monitor textures and shaders folders and automatic reloading when they are changed.
* tga loader for opengl textures.
* setting up and using a streaming opengl buffer.
* orthographic projection
* printing without stdio.h

Note day one the first 20 mins or so I didn't realise the screen was blank (I was really tired!)

[strike]I'll be archiving the streams on youtube as well once I figure that out.[/strike]

Youtube Archive: Link

List is updated. Notice I'm now only adding large, ongoing projects to the list, but I'll add an official section of the small completed programs at earliest convenience.