Goal: A complete set of files which you can build in order to obtain a complete OS ROM, with proper labels and equates, so modifications are easy.


I'm basing it on OS 2.41, primarily because of BrandonW's extensive work on a disassembly of that particular version. Without that, this would be much harder.


The code is made to be compilable with Brass, benryyves' assembler. This means it can be compiled with any x86 OS that supports mono, and if you can get the DCS SDK you should be all set.


The easiest mods that would have a directly beneficial effect would be optimizations to bcalls. This would directly increase the performance of the system as a whole.


Progress:
Page | Status
00   | Succesful Build
01   | Pending
02   | Pending
03   | Pending
04   | Pending
05   | Pending
06   | Pending
07   | Pending
08-6e| Empty
6f   | Pending
70-73| Empty
74   | Pending
75   | Pending
76   | Pending
77   | Pending
78   | Pending
79   | Pending
7a   | Pending
7b   | Pending
7c   | Pending
7d   | Pending
7e   | Empty
7f   | Pending


Here's my contest entry so far.

Toy Wars
A simple, easy to play turn based strategy game.

I've been working on the map system. The plans right now are up to 5 players, with each being selectable as AI or a player. Teams cannot be allies. If you want to be allies, then be the same team.

Each unit can move one square, attack, or use an item. An order is in the form of a direction only. Teams move all their units simultaneously, so a turn may have you making upwards of 20 actions.

Each unit represents six soldiers, each with their own health bar and attack. Attacks are non-random in terms of damage, but random in terms of which soldier they hit. Thus, battles, while predictable and fair, are still never quite the same. (One team loses a soldier early, dealing less damage)

Shelters restore each soldier left in the unit by 1 HP, consuming one use in the process.

There will also be various forms of ranged weapons including lasers (straight line away from user), cannons (explosion away from user), and other items.

Other non-unit items include breakable and non-breakable barricades, one-time health packs, etc. (I am taking suggestions as long as they're reasonable)

The editor is already mostly finished. Changing a unit type takes some time, unfortunately, but I can't think of a way to make it any faster than it is. (it already does dirty unit checks so it doesn't redraw the whole map) Changing health is much faster.

The map generator is extremely simple right now. It generates random numbers and places them in the map if they're valid. Health is always 999999 (full) for soldiers, and a random int from 5 to 15 for houses.

I figure with 5 teams and a fair amount of terrain, the replay value should be quite high.

The screenie is a little slow, since it's running in an 83+ on the emu. On an 84+ it runs a fair amount faster (but never as fast as I'd like: The cursor is reasonable instead of unbearable, but not really fast)

So, I've set up a minecraft server. It runs 24/7 as of now.

It has a mod that gives a console-based shop, but all offers are player to player.

The currency is flint-based, and is kept in chests marked by signs. No protection on those chests, so players can just take the money out!

There's a multi-home plugin, with unlimited named homes.

Raiding is allowed, Griefing is not. Difference is that one is for personal profit, the other is for antagonistic/destructive/trolling purposes. ie there's no reason to blow up someone's house, but you are perfectly justified to take their diamond statue.

Anyway, the IP is:

A01514559-1.bluezone.usu.edu:25565

We need more players to get a stable economy going! There's already enough stuff at the shop that you won't want for materials, and the world is mostly untouched.


tl;dr: Mostly Vanilla, player-based economy, pvp/raiding allowed, griefing not allowed.

So, here's the topic where we'll discuss the coding of the game.

This thread is for discussing pretty much anything relating the the Omni-RPG community game. Sub threads currently are:

• Storyline
• Battle Engine

The Omnimaga RPG project is intended to be a community-created large scale project. That means anyone is eligible to help. There is some management by specific members to keep things organized, but there are still tons of things that other members can do.

So, this is an idea that would help boost activity, while also helping members get more acquanted with programming.

Programming Challenges

Community based programming events seem to have boosted activity in the past. Ie, portal X, the Summer programming contests, ndless, etc. so I figure we could get a more stabilized activity base by having continuous events.

Types of Events

Individual
Team [Up to 2, Up to 4, etc.]
Super Co-Op (The whole community contributes to one project, excepting one impartial person who then judges each person's contributions for points. It's mostly for the awesomeness of doing something, though)

TI-84+
Prizm
Nspire

Easy [expected <24 hrs]
Medium [expected <3 days]
Hard [expected <1 Week]
Insane [>1 week]
Lunatic [>1 month] (go Touhou )

You start a new Easy and Medium challenge every week, and one Hard, Lunatic and Insane challenge after 1 month.

Graphics-based
Math
Random

We should have randomly chosen teams, but each would contain a certain amount from different pools. As in, there would be a pool of users good at graphics, a pool good at the programming, map design, etc.


Example scoring system (I'm coming up with it on the spot. Criticism is welcome. )

100 points for every hour after it has been announced. (you do percentages of hours rounded to 1 point)
24000 points for not working 100% (This is for those Lunatic Challenges. It would give people 10 days to beat a nonworking entry)
1 point for each byte in the runtime file. This gives an advantage to Axe/Asm over BASIC/Grammer.
1 point for every frame/millisecond/whatever it takes to run, past the execution point. (pressing enter)
-(A fair amount) for creativity, etc. (If someone mimics another person's program, they would get less creativity, so they would have to come up with a big optimization to compensate. I don't think basing off another's program is bad this way, since they'd also be behind on time.)

What counts for the bytes is any non-language based (grammer, Axe Fusion) requirement for a program to run. If it needs external variables defined BEFORE execution, then those variables count as well.
(I'm looking at basic here: Defining 10->A where A is unknown does NOT count A)
Basically, if you need to send it to the calc for your program, and not for any other program, it counts.

Points are BAD.

Asm programs should be run with Asm(prgmNAME), and Axe programs should be compiled so they can run the same way. This is because timing problems would result from running MirageOS/DoorsCS/Ion start methods.

There should be a website with a live-updating countdown method of some sort, so it shows the challenge to everyone at the same time regardless of refreshes.


Prizes

Since they're weekly, there shouldn't be IRL prizes (money is expensive!) but maybe we should bring back the trophy system, but for this. Clicking on the trophy would take you to their zip in the file archives.

Oh, and the entries should be open source. We should have the community development skill increase as people see others' methods for running programs faster. These programs aren't going to be massive games or anything, and it's not a huge deal if someone undercuts you.

[size=24]Some Details[/size]

Reentries are allowed, but invalidate previous entries. If it's the same entry twice, then you just add to your time score.
Entering code that is not all yours is fine. (Axioms, Grammer Libs, Someone else's source) If you have the resources to find something for this contest that fast, then the community will benefit from it. If you rip off someone's entry, you're behind them on both time AND creativity.

A few example challenges: [stuff] means replace with specifics.
* make a program that displays the result of [some (hard) math operation]
* make a program that can draw [3d, lots of grey, etc.]
* make a program that [does something] in an especially creative way.

One potential problem is the time delay between the different time zones we are in. I believe we have 3 separate general regions to deal with (americas, europe, eastern asia) and I have a few thoughts on that as well.
* Have the start base on local time, so everyone starts at 5:00 PM in their area.
* Ignore the problem, and make the challenges hard enough that it's negligible. (ie they take 3-4 days)
* Cycle through starting times, so everyone gets a head start at some point.

Just a little project I'm working on. It's not working yet, but it should be  :banghead:

[code]#!/usr/bin/env python2
# -*- coding: utf-8 -*-
#
#  untitled.py
# 
#  Copyright 2012 Unknown <william@willdesktop>
# 
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
#  MA 02110-1301, USA.
# 
# 
import sys

try:
prog = open(sys.argv[1],'r')
except IndexError:
print ("Usage: python script program")
exit()
except IOError:
print("File Not Found")
exit()

BYTE_MAX = 255 #These values are the default for an 8-bit implementation.
ARRAY_MAX = 29999

loops = {}
ptr = 0

array = []
for a in range(30000): #Give array the proper dimensions
array += [0]


#These are the executing functions for the commands.

def inc_ptr():
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
ptr += 1
if ptr > ARRAY_MAX:
ptr = 0

def dec_ptr():
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
ptr += -1
if ptr == -1:
ptr = ARRAY_MAX

def inc_byte():
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
array[ptr] += 1
if array[ptr] > BYTE_MAX:
array[ptr] = 0

def dec_byte():
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
array[ptr] += -1
if array[ptr] == -1:
array[ptr] = BYTE_MAX

def out_byte():
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
print (chr(array[ptr]))

def in_byte():
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
array[ptr] = ord(input("In: ")[0:1]) #Python3 uses input, python2 uses raw_input. change if it nameErrors. (2 because of unrecognized chars, 3 because raw_input is meaningless.)

def in_loop(run_line):
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
if array[ptr] == 0:
run_line = loops[run_line]
print ("Jumped to "+str(run_line))

def out_loop(run_line):
global ptr,ARRAY_MAX,BYTE_MAX,loops,array
if array[ptr] != 0:
run_line = loops[run_line]
print ("Returned to "+str(run_line))

#These are other functions, mostly for startup prep.

def find_loops():
global loops
global prog
op_num = 0
in_loops = []
out_loops = []
for line in prog:
for char in line:
if char == "[":
in_loops += [op_num]
if char == "]":
out_loops += [op_num]
op_num += 1

if len(in_loops) != len(out_loops):
print ("Error: Nonmatching bracket count.")
exit()

for a in range(len(in_loops)):
loops[in_loops[a]]  = out_loops[a]
loops[out_loops[a]] =  in_loops[a]
print ("Found "+str(len(in_loops))+" loops")

def filter_prog(): #Currently unused
global prog
op_str = ""
for line in prog:
for char in line:
if char in "><+-.,[]": #Eliminate useless characters
op_str += char
op_str += "!" #Signals an EOF. Don't worry, you can still have ! in the file elsewhere.
return op_str

def exec_op_str(op_str):
op = ''
op_num = 0
while op != '!':
op = op_str[op_num]

#Contains the if statements for all the commands, executing them.
if True: #For grouping purposes
if op == ">":
inc_ptr()

if op == "<":
dec_ptr()

if op == "+":
inc_byte()

if op == "-":
dec_byte()

if op == ".":
print ("Printed a char")
out_byte()

if op == ",":
in_byte()

if op == "[":
in_loop(op_num)

if op == "]":
out_loop(op_num)
op_num += 1


def main():
global array, prog
find_loops()
prog.seek(0)
op_str = prog.read()
exec_op_str(op_str)
print (array[0:100])
return 0

if __name__ == '__main__':
main()

Oh btw {code} turned my tabs into spaces, but the code should still work fine.[/code]