@@ -6,14 +6,34 @@ from .combat_parts import skills

 from .combat_parts import constants as const

 import collections

+import random

+

+def get_stats(sum_):

+	stats = [sum_/4]*4

+	if sum(stats) != sum_:

+		stats[0] += sum_ - sum(stats)

+

+	mod = +1

+	for x in range(100):

+		idx = random.choice([x for x in range(len(stats)) if stats[x] > 3])

+		stats[idx] += mod

+		mod *= -1

+	return stats

 class Attributes(object):

+	@classmethod

+	def randomize(cls, sum_):

+		chosen_stats = get_stats(sum_)

+		return cls(*chosen_stats)

+

 	def __init__(self, strength, intellect, dexterity, spirit):

 		self.str = strength

 		self.int = intellect

 		self.dex = dexterity

 		self.spt = spirit

 		self.state = const.HEALTHY

+	def __str__(self):

+		return '%s %s %s %s %s' % (self.str, self.int, self.dex, self.spt, self.state)

 @equipment.Slot.add_slot('weapon', equipment.Weapon)

@@ -28,9 +48,26 @@ class Adventurer(object):

 			raise ValueError('Value for state invalid')

 		self.attributes.state = val

-	def __init__(self, name, race, str, int, dex, spt):

+	@classmethod

+	def randomize(cls, stat_sum=28):

+		name = '%s %s%s' % (

+			random.choice(['Bill', 'Bob', 'Jerry']),

+			random.choice(['Longnose', 'Short-Tail', 'Squint']),

+			random.choice(['', ' the Great', ' The Cross-eyed', ' The Magnificent'])

+		)

+		race = races.Race.random_race()

+		attr = Attributes.randomize(stat_sum)

+		print attr

+		return cls(name, race, attr)

+

+	@classmethod

+	def with_stats(cls, name, race, str, int, dex, spt):

+		attr = Attributes(str, int, dex, spt)

+		return cls(name, race, attr)

+

+	def __init__(self, name, race, attr):

 		self.name = name

-		self.attributes = Attributes(str, int, dex, spt)

+		self.attributes = attr

 		self.skills = skills.Skills(self.attributes)

 		self.race = races.Race.registry[race](self.attributes)

@@ -73,20 +110,9 @@ class Adventurer(object):

 	def die(self): pass

-def get_stats():

-	stats = [7,7,7,7]

-	import random

-	mod = +1

-	for x in range(100):

-		idx = random.choice([x for x in range(len(stats)) if stats[x] > 5])

-		stats[idx] += mod

-		mod *= -1

-	print sum(stats), stats

-	return stats

-

 if __name__ == '__main__':

-	a = Adventurer('bob', 'elf', *get_stats())

-	b = Adventurer('bill', 'elf', *get_stats())

+	a = Adventurer.randomize(28)

+	b = Adventurer.randomize(28)

 	while const.KNOCKOUT not in {a.state, b.state}:

 		a.attack(b)

@@ -8,7 +8,8 @@ class Race(object):

 	@classmethod

 	def random_race(cls):

-		return random.choice(self.registry.values())

+		return random.choice(cls.registry.keys())

+

 	@property

 	def name(self):

 		return self.__class__.__name__.lower()

@@ -34,13 +35,13 @@ class Elf(Race):

 @Race.register

 class Dwarf(Race):

 	allowed_professions = {'fighter', 'Priest', 'thief'}

-	def mod(self, atr):

+	def mod(self, attr):

 		attr.str += 1

 @Race.register

 class Hobbit(Race):

 	allowed_professions = {'thief', 'barbarian'}

-	def mod(self, atr):

+	def mod(self, attr):

 		attr.dex += 1

@@ -25,8 +25,13 @@ class Skills(object):

 		self.training = Trainer(self)

 		self.train = self.training.select

-	def check(self, skill, dieroll):

-		dieroll.dice = dice.DieJar().d20

+	def check(self, skill, dieroll=None):

+		die = dice.DieJar().d20

+		if dieroll is None:

+			dieroll = die

+		else:

+			dieroll.dice = dice.DieJar().d20

+

 		roll = dieroll.roll()

 		if roll == 1:

 			result = False

@@ -1,7 +1,8 @@

 import abc

+from . import combat

 class Overlay(object):

-	__metaclass__ = abs.ABCMeta

+	__metaclass__ = abc.ABCMeta

 	char = abc.abstractproperty()

 	color = (0,0,0)

@@ -29,6 +30,9 @@ class Actor(Overlay):

 		self.x = x

 		self.y = y

 		self.map = map

+		if adventurer is None:

+			adventurer = combat.Adventurer.randomize()

+		self.adventurer = adventurer

 	def draw(self):

 		self.map.add(self)

@@ -42,9 +46,22 @@ class Actor(Overlay):

 		pass

+	def ishostile(self, other):

+		return True #TODO: implement factions

+

 	def bump(self, other):

 		print '%s bumped %s' % (type(self).__name__, type(other).__name__)

+		if isinstance(other, Actor) and other.ishostile(self):

+			self.adventurer.attack(other.adventurer)

+			other.attacked_by(self)

 		other.bumped_by(self)

+

+	def attacked_by(self, other):

+		if self.adventurer.state >= 2:

+			self.char = '%'

+		elif self.adventurer.skills.check('agility'):

+			self.adventurer.attack(other.adventurer)

+

 	def bumped_by(self, other):

 		print '%s was bumped by %s' % (type(self).__name__, type(other).__name__)

@@ -5,9 +5,10 @@ random.seed(2)

 import libtcodpy as tc

 import numpy as np

+from libs import overlay

+from libs import combat

 from src import events

 from src import player

-from libs import actor

 from src import console

 from src import map

@@ -20,17 +21,17 @@ class Application(object):

 		self.terrain_registry = map.TerrainRegistry()

 		self.terrain_registry.load_from_file('data/terrain.yml')

 		self.map = map.Map(100,63, self.terrain_registry)

-		self.player = player.Player(4,5, self.map)

+		self.player = player.Player(4,5, self.map, combat.Adventurer.randomize())

 		self.events = events.EventHandler()

 		player.ArrowHandler(self.player, self.events)

 		self.actors = []

 		for x in range(40):

-			self.actors.append(actor.Actor(random.randrange(100), random.randrange(63), self.map))

+			self.actors.append(overlay.Actor(random.randrange(100), random.randrange(63), self.map))

 		self.objects = []

 		for x in range(50):

-			self.objects.append(

+			self.objects.append(overlay.Potion(random.randrange(100), random.randrange(63), self.map))

 		tc.sys_set_fps(60)

@@ -1,16 +1,16 @@

 import libtcodpy as tc

 import libs.combat

-import libs.actor

+import libs.overlay

-class Player(libs.actor.Actor):

+class Player(libs.overlay.Actor):

 	char = ord('@')

 	color = (255,255,255)

 	light_radius = 10

-	def __init__(self, x,y, map):

-		libs.actor.Actor.__init__(self, x,y, map)

+	def __init__(self, x,y, map, adventurer):

+		libs.overlay.Actor.__init__(self, x,y, map, adventurer)

 		self.map.set_pov((self.pos, self.light_radius))

 	def move(self, dx, dy):

-		libs.actor.Actor.move(self, dx,dy)

+		libs.overlay.Actor.move(self, dx,dy)

 		self.map.set_pov((self.pos, self.light_radius))

 class ArrowHandler(object):