# -*- test-case-name: mv3d.test.test_worldgen -*- # Copyright (C) 2006-2012 Mortal Coil Games # See LICENSE for details. """ Create a basic demo world for test use (or to demo MV3D) @todo: hit this file with the refactor hammer """ import random import logging from time import time from twisted.internet.defer import inlineCallbacks, returnValue from twisted.python.log import deferr from zope.interface import implements #@UnresolvedImport from mv3d.util.math3d import Quaternion, Vector from mv3d.util.classgen import ClassGenerator from mv3d.util.iservice import ISimulationClient, IAssetClient, IRealmClient from mv3d.server.account import Account, IAccountService from mv3d.server.directory import IDirectoryService from mv3d.server.sim import ISimulationService from mv3d.server.asset import IAssetService from mv3d.server.model.realm import SimpleCharacterGenerator from mv3d.phys.mesh import (NoiseHeightGenerator, HeightField, MeshGenStaticBody, MeshGenVisualObject) from mv3d.phys.scenery import Grass, Scenery, SceneryPiece from mv3d.phys.body import StationaryBody from mv3d.resource.ogre3d import newURLOgreMeshAsset from mv3d.resource.ogre3d import newURLOgreMaterialAsset from mv3d.resource.url import newURLFileAsset, newURLImageAsset from mv3d.server.factory import IFactory from mv3d.server.sim import SimCluster from mv3d.server.model.octree import OctreeArea from mv3d.server.persist import SQLiteStore, Freezer, FrozenItem, \ FreezeCategories from mv3d.resource.panda import newURLPandaMeshAsset from mv3d.phys.iphys import IBoxCollider, IPlaneCollider from twisted.python import log @inlineCallbacks def setupServer(conductor, opts): """ Bootstrap a server. User can specify a factory or a template to be loaded with the template factory. """ try: initialize = bool(opts['initialize']) if not initialize: return factoryClass = opts['worldgen-factory'] templateFile = opts['worldgen-template'] freezeFile = opts['import-from'] if freezeFile is not None: dsvc = conductor.getLocalService(IDirectoryService) yield dsvc.newMasterDirectory("AssetGroups") yield dsvc.newMasterDirectory("Realms") store = SQLiteStore() store.open(freezeFile) freezer = Freezer(store) assetGroups = FrozenItem.query(store, FrozenItem.category == FreezeCategories.assetGroup) for assetGroup in assetGroups: yield freezer.thawAssetGroup(assetGroup, conductor) realms = FrozenItem.query(store, FrozenItem.category == FreezeCategories.realm) sim = conductor.getLocalService(ISimulationService) simCluster = SimCluster("self/%s" % sim.name) sim.addPool(simCluster) for realm in realms: yield freezer.thawRealm(realm, simCluster, conductor) returnValue(None) if templateFile is not None: factoryClass = "mv3d.server.factory.Template" factoryClass = ClassGenerator(factoryClass) factory = yield factoryClass.construct(conductor) if templateFile is not None: factory.view_setTemplate(None, templateFile) factory.giveInput(opts) yield factory.produce() conductor.log("Done setting up world", logLevel=logging.INFO) except: deferr() raise class Assets: """ A default version of the standard assets """ playerassets = None cubeasset = None trees = None terrainmaterials = None grass = None colormap = None skyassets = None waterassets = None def __init__(self, conductor): self.conductor = conductor @inlineCallbacks def build(self): """ Grab the assets out of the asset service """ service = self.conductor.getLocalService(IAssetClient) armored_swordman = yield service.getAsset((0, 10)) ninja2 = yield service.getAsset((0, 23)) robot1 = yield service.getAsset((0, 27)) dragon = yield service.getAsset((0, 31)) self.playerassets = [ {u"name":"armored_swordman", u"models":[armored_swordman], u"scale":(0.02, 0.02, 0.02)}, {u"name":"ninja2", u"models":[ninja2], u"scale":(0.025, 0.025, 0.025), u"offset":[(0, -0.5, 0), (1, 0, 0, 0)]}, {u"name":"robot", u"models":[robot1], u"scale":(0.025, 0.025, 0.025)}, {u"name":"dragon", u"models":[dragon], u"scale":(0.02, 0.02, 0.02)}, ] self.cubeasset = yield service.getAsset((0, 6)) self.trees = [(0, 14)] terrainMat = yield service.getAsset((0, 5)) self.terrainmaterials = [terrainMat] self.grass = yield service.getAsset((0, 18)) self.colormap = yield service.getAsset((0, 19)) clearsky = yield service.getAsset((0, 32)) atmos = yield service.getAsset((0, 33)) sungrad = yield service.getAsset((0, 34)) shaders = yield service.getAsset((0, 35)) clouds = yield service.getAsset((0, 41)) stars = yield service.getAsset((0, 42)) sphere = yield service.getAsset((0, 43)) self.skyassets = [clearsky, sungrad, sphere, shaders, clouds, stars, atmos] material = yield service.getAsset((0, 47)) self.waterassets = [material] def selectPosition(area, bounds): """ Returns a random position within the bounds. Either Y coord can be None which will cause that bound to be ignored. """ assert bounds[0][1] > -1000 or bounds[0][1] is None assert bounds[1][1] < 1000 or bounds[1][1] is None for _ in range(1000): pos = (random.random() * (bounds[1][0] - bounds[0][0]) + bounds[0][0], 0, random.random() * (bounds[1][2] - bounds[0][2]) + bounds[0][2]) top = (pos[0], 1000, pos[2]) bottom = (pos[0], -1000, pos[2]) ray = area.getDisabledSpace().castRay(top, bottom) if ray.mindepth < 2000: posy = 1000 - ray.mindepth if bounds[1][1] is None or posy < bounds[1][1]: if bounds[0][1] is None or posy > bounds[0][1]: return (pos[0], posy + 4, pos[2]) raise ValueError("Couldn't place item within bounds %r" % (bounds,)) class CharacterFactory: """ A factory for building PCs """ implements(IFactory) assets = None paramInfo = dict( assets=dict(), bounds=dict(), names=dict(), forPanda=dict(), ) def __init__(self, parent, forPanda=False, name="Player"): self.area = parent self.bounds = (-1000, None, -1000), (1000, None, 1000) self.names = [name] self.forPanda = forPanda @inlineCallbacks def produce(self): """ Produce a character """ log.msg("Creating a character. Panda=%s" % self.forPanda) try: pos = selectPosition(self.area, self.bounds) except ValueError: pos = (0, 0, 0) # print "using default pos!" charID = yield self.area.newItem( Vector(pos) + (0, 2, 0), ClassGenerator("mv3d.server.model.physical.PhysicalBiped")) char = self.area.sim.items[charID] char.setPosition(Vector(pos) + (0, 2, 0)) if not self.forPanda: asset = random.choice(self.assets.playerassets) char.addModels([mod.getID() for mod in asset["models"]]) char.setScale(asset["scale"]) if asset.has_key("offset"): char.setVisualOffset(asset["offset"][0], asset["offset"][1]) else: off = (0, -1.5, 0) #-3.5 quat = Quaternion() char.setVisualOffset(off, quat) else: asset = self.assets.pandaassets["alice"] char.addModels([asset.getID()]) char.setScale((0.2, 0.2, 0.2)) off = (0, -2.5, 0) #-3.5 quat = Quaternion.fromEuler((0, 3.14, 0)) char.setVisualOffset(off, quat) char.setPosition((0, 15, 0)) asset = self.assets.playerassets[0] char.body.vobs[0].controllerID = asset["controller"].getID() char.setName(random.choice(self.names)) char.addManipulatorClass("Player Manipulator", ClassGenerator("mv3d.server.player.PlayerManipulator")) char.addManipulatorClass("World Editor", ClassGenerator("mv3d.server.Interface.WorldEditor.WorldEditor")) yield char.deactivate() char.save(self.area.sim.store) returnValue(charID) class TerrainFactory: """ A factory for building Terrains """ implements(IFactory) assets = None grass = False paramInfo = dict( assets=dict(), terrainWidth=dict(), position=dict(), offset=dict(), scale=dict(), grass=dict(), seed=dict(), resolution=dict(), multiplier=dict(), ) def __init__(self, parent): self.area = parent self.terrainWith = 2 #3 self.position = (0, 0, 0) self.offset = (0, 0) self.scale = (1000, 1000) self.seed = 1523 self.resolution = (30, 30) self.multiplier = (4.0, 100.0, 4.0) @inlineCallbacks def produce(self): """ Create the terrain """ log.msg("Creating terrain.") terrainID = yield self.area.newItem(self.position, ClassGenerator("mv3d.server.model.physical.BasicPhysicalObject")) terrain = self.area.sim.items[terrainID] terrain.setName(u"Ground%r" % (terrainID,)) hgen = NoiseHeightGenerator(offset=(self.offset[0], 0.2, self.offset[1]), seed=self.seed, multiplier=self.multiplier) hfield = HeightField(resolution=self.resolution, size=self.scale, heightGenerator=hgen) mgsb = MeshGenStaticBody(meshGen=hfield) mgsb.addVisualObject(MeshGenVisualObject(meshGen=hfield, materialAssetId=self.assets.terrainmaterials[0].getID())) if self.grass: grass = Grass((self.offset[0] * 1000 - (self.terrainWith * 500), self.offset[1] * 1000 - (self.terrainWith * 500), (self.offset[0] + 1) * 1000 - (self.terrainWith * 500), (self.offset[1] + 1) * 1000 - (self.terrainWith * 500)), hfield, maxDist=300) grass.addLayer(self.assets.grass.getID(), density=0.3, bounds=grass.bounds, colorMapAssetId=self.assets.colormap.getID(), heightRange=(0.5, 100.0)) mgsb.addVisualObject(grass) grass.grantPermission("read", "all") grass.grantPermission("reference", "all") terrain.setBody(mgsb) mgsb.grantPermission("read", "all") mgsb.grantPermission("reference", "all") hgen.grantPermission("read", "all") hgen.grantPermission("reference", "all") hfield.grantPermission("read", "all") hfield.grantPermission("reference", "all") mgsb.getVisualObjects()[0].grantPermission("read", "all") mgsb.getVisualObjects()[0].grantPermission("reference", "all") terrain.addModifier("ige", ClassGenerator("mv3d.server.ige.server.Terrain")) returnValue(terrainID) class OceanFactory: implements(IFactory) assets = None paramInfo = dict( assets=dict(), ) def __init__(self, parent): self.area = parent @inlineCallbacks def produce(self): """ Add a water mesh """ log.msg("Creating water.") waterID = yield self.area.newItem((0, 0, 0), ClassGenerator("mv3d.server.model.physical.WaterPlane")) water = self.area.sim.items[waterID] for asset in self.assets.waterassets: water.addVisualAsset(asset.getID()) class AccountFactory: implements(IFactory) accountName = None password = None paramInfo = dict( accountName=dict(), password=dict(), ) def __init__(self, parent): self.service = parent def produce(self): """ Create account based on the given name """ account = Account(username=self.accountName, password=self.password) account.grantPermission("read", "all") account.grantPermission("reference", "all") self.service.addAccount(account) return account class RealmFactory: implements(IFactory) assets = None paramInfo = dict( assets=dict(), ) def __init__(self, realmService): self.service = realmService @inlineCallbacks def produce(self): rid = yield self.service.newMasterRealm( ClassGenerator("mv3d.server.model.realm.odeRealm")) realm = self.service.pools[rid].realm realm.setName(u"The Realm") realm.setPhysicsProperty("gravity", Vector(0, -9.81, 0)) realm.sky.setAssets([asset.getID() for asset in self.assets.skyassets]) passets = [] for ppla in self.assets.playerassets: asset = dict(scale=ppla["scale"], name=ppla["name"]) if ppla.has_key("offset"): asset["offset"] = ppla["offset"] asset["models"] = [] for model in ppla["models"]: asset["models"].append(model.getID()) asset["controller"] = ppla["controller"].getID() passets.append(asset) cgen = SimpleCharacterGenerator(self.service, [(0, 0), (0, 8)], passets, ["self/Account"]) realm.setCharacterGenerator(cgen) cgen.grantPermission("read", "all") cgen.grantPermission("modify", "all") returnValue(rid) class AreaFactory: implements(IFactory) realmID = None realmService = None paramInfo = dict( realmID=dict(), realmService=dict(), ) def __init__(self, simService): self.sim = simService def produce(self): log.msg("Creating area.") return self.sim.newMasterArea( ClassGenerator("mv3d.server.model.octree.OctreeArea"), self.realmID) class Multi: implements(IFactory) count = 0 child = None paramInfo = dict( count=dict(), child=dict() ) @inlineCallbacks def produce(self): results = [] for _ in xrange(self.count): result = yield self.child.produce() results.append(result) returnValue(results) class WorldGenerator: """ This is a way to generate a small world procedurally """ implements(IFactory) paramInfo = dict( nplayers=dict(), ncubes=dict(), terrain=dict(), trees=dict(), grass=dict(), addDirectories=dict(), addAssetGroup=dict(), addAssets=dict(), addRealm=dict(), addArea=dict(), addTerrain=dict(), addOcean=dict(), addBounds=dict(), addAccount=dict(), makeAdmin=dict(), username=dict(), password=dict(), addCharacter=dict(), ) nplayers = 1 ncubes = 0 terrain = 2 trees = 0 grass = 0 assets = None area = None realm = None addDirectories = True addAssetGroup = True addAssets = True addRealm = True addArea = True addTerrain = True addOcean = True addBounds = True addAccount = True makeAdmin = True addCharacter = True makePandaWorld = True username = "admin" password = "pass" def __init__(self, server): self.server = server self.dsvc = self.server.getLocalService(IDirectoryService, None) self.rsvc = self.server.getLocalService(IRealmClient, None) self.asvc = self.server.getLocalService(IAssetService, None) self.sim = self.server.getLocalService(ISimulationService, None) self.acctsvc = self.server.getLocalService(IAccountService, None) def giveInput(self, options): """ Give this factory some input """ for option in self.paramInfo.keys(): if options.has_key(option): setattr(self, option, options[option]) @inlineCallbacks def produce(self): """ Create the world! BAM! """ start = time() log.msg("Started world generation.") if self.addDirectories: startd = time() log.msg("Creating directories...") yield self.dsvc.newMasterDirectory("AssetGroups") yield self.dsvc.newMasterDirectory("Realms") log.msg("Created directories in %.2f seconds." % ( time() - startd)) if self.addAssetGroup: log.msg("Adding asset group...") grpid = yield self.asvc.newMasterAssetGroup(ClassGenerator( "mv3d.server.asset.AssetGroup")) if self.addAssets: starta = time() self.assets = AssetCreator(self.server, self.asvc.getAssetGroup(grpid).group) yield self.assets.addAssets() log.msg("Created assets in %.2f seconds." % ( time() - starta)) if self.assets is None: self.assets = Assets(self.server) yield self.assets.build() if self.addRealm: startr = time() log.msg("Creating realm...") rfact = RealmFactory(self.rsvc) rfact.assets = self.assets rid = yield rfact.produce() self.realm = yield self.rsvc.getRealm(rid) pool = SimCluster(self.sim.publicLocation) self.sim.addPool(pool) if self.addArea: afact = AreaFactory(self.sim) afact.realmService = self.rsvc afact.realmID = rid aid = yield afact.produce() self.area = self.sim.pools[aid] if self.addTerrain: tfact = TerrainFactory(self.area) tfact.assets = self.assets yield tfact.produce() if self.addOcean: ofact = OceanFactory(self.area) ofact.assets = self.assets yield ofact.produce() if self.addBounds: yield self.createBumpers(self.area) if self.makePandaWorld: afact = AreaFactory(self.sim) afact.realmService = self.rsvc afact.realmID = rid aid = yield afact.produce() self.pandaArea = self.sim.pools[aid] iid = yield self.pandaArea.newItem((0, 0, 0), ClassGenerator( "mv3d.server.model.physical.BasicPhysicalObject")) ground = self.sim.items[iid] ground.setName("Ground") ground.body = StationaryBody() ground.body.representationID = self.assets.pandaassets[ "solidGround"].getID() ground.grantPermission("read", "all") ground.grantPermission("reference", "all") ground.body.grantPermission("read", "all") ground.body.grantPermission("reference", "all") ground.save() log.msg("Created realm in %.2f seconds." % (time() - startr)) if self.addAccount: actfact = AccountFactory(self.acctsvc) actfact.accountName = self.username actfact.password = self.password account = yield actfact.produce() if self.makeAdmin: account.addGroup("admin") if self.addArea and self.addCharacter and self.area is not None: charfact = CharacterFactory(self.area) charfact.assets = self.assets pcid = yield charfact.produce() account.addPC(pcid) if self.addCharacter and self.makePandaWorld: charfact = CharacterFactory(self.pandaArea, True, "Panda Player") charfact.assets = self.assets pcid = yield charfact.produce() account.addPC(pcid) log.msg("World generation finished in %.2f seconds." % (time() - start)) def createBox(self, o, a, x, r): """ Create a box in the area """ o.create(r) mx = self.ncubes * 10.0 if mx > self.terrain * 1000.0: mx = self.terrain * 1000.0 mn = mx / 2.0 o.setName(u"Box%d" % x) o.setPosition((random.random() * mx - mn, random.random() * 100 + 100, random.random() * mx - mn)) o.addVisualAsset(self.assets.cubeasset.getID()) o.body.vobs[0].setScale((0.05, 0.05, 0.05)) for x in xrange(10): p1 = (random.random() * mx - mn, 1000, random.random() * mx - mn) p2 = (p1[0], -1000, p1[2]) r = a.world.castRay(a.getDisabledSpace(), p1, p2) if r.mindepth < 5000: o.setPosition((p1[0], 1100 - r.mindepth, p1[2])) break # else: # print "Not on ground!" @inlineCallbacks def createTrees(self, trees): """ Create some trees """ o = yield self.area.newObject(ClassGenerator( modulename="mv3d.server.model.physical", classname="BasicPhysicalObject")) o.setBody(Scenery()) mx = self.terrain * 1000.0 mn = mx / 2.0 o.setName(u"Trees1") for _z in range(trees): sp = SceneryPiece() for _x in xrange(10): p1 = (random.random() * mx - mn, 1000, random.random() * mx - mn) p2 = (p1[0], -1000, p1[2]) r = self.area.world.castRay(self.area.getDisabledSpace(), p1, p2) if r.mindepth < 5000 and 1000 - r.mindepth > 0: sp.addVisualAsset(random.choice(self.assets.trees), (p1[0], 1000 - r.mindepth, p1[2])) sp.colliders.append(self.area.world.getPhysicsClass( IBoxCollider)(position=(p1[0], 1010 - r.mindepth, p1[2]), size=(2, 20, 2))) o.body.addPiece(sp) break o.create(self.realm) @inlineCallbacks def createAssets(self, agid): """ Set up the assets required by this world generator """ agrp = self.server.getLocalService(IAssetService).getAssetGroup(agid) self.assets = AssetCreator(agrp) yield self.assets.addAssets() @inlineCallbacks def createdArea(self, r): """ This is called when an area has been created. It sets up some thing related to the new area along with some realm stuff """ a = yield self.server.getLocalService(ISimulationClient).getItem(r) a.setName(u"MV3D Area %d" % r[1]) a.initializePhysics() self.area = a # sim = self.server.getLocalService(ISimulationService) p = self.assets.playerassets passets = [] for pp in p: d = dict(scale=pp["scale"], name=pp["name"]) if pp.has_key("offset"): d["offset"] = pp["offset"] d["models"] = [] for m in pp["models"]: d["models"].append(m.getID()) passets.append(d) if self.realm.getCharacterGenerator() is None: rs = self.server.getLocalService(IRealmClient) cg = SimpleCharacterGenerator(rs, [self.area.getID()], passets, ["self/Account"]) cg.grantPermission("read", "all") cg.grantPermission("modify", "all") self.realm.setCharacterGenerator(cg) else: self.realm.getCharacterGenerator().areaIds.append(self.area.getID()) @inlineCallbacks def createCubes(self, ncubes): """ Create ncubes cubes in random positions. """ for x in range(ncubes): b = yield self.area.newObject(ClassGenerator( modulename="mv3d.server.model.physical", classname="PhysicalBox")) self.createBox(b, self.area, x, self.realm) @inlineCallbacks def createBumpers(self, area=None): """ Create 5 walls to prohibit the player from falling off the edges of the map (or from falling below the ground) """ if area is not None: bounds = area.getBounds() else: t1000by2 = self.terrain * 1000 / 2.0 bounds = (-t1000by2, -100, -t1000by2), (t1000by2, 1000, t1000by2) area = self.area left = yield area.newItem((0, 0, 0), ClassGenerator( "mv3d.server.model.physical.BasicPhysicalObject")) left = yield self.sim.getItem(left) left.setBody(StationaryBody()) left.setName("left boundary") Plane = area.world.getPhysicsClass(IPlaneCollider) left.body.addCollider(Plane(normal=(1, 0, 0), distance= -bounds[0][0])) right = yield area.newItem((0, 0, 0), ClassGenerator( "mv3d.server.model.physical.BasicPhysicalObject")) right = yield self.sim.getItem(right) right.setBody(StationaryBody()) right.setName("right boundary") right.body.addCollider(Plane(normal=(-1, 0, 0), distance= -bounds[1][0])) front = yield area.newItem((0, 0, 0), ClassGenerator( "mv3d.server.model.physical.BasicPhysicalObject")) front = yield self.sim.getItem(front) front.setBody(StationaryBody()) front.setName("front boundary") front.body.addCollider(Plane(normal=(0, 0, 1), distance= -bounds[0][2])) back = yield area.newItem((0, 0, 0), ClassGenerator( "mv3d.server.model.physical.BasicPhysicalObject")) back = yield self.sim.getItem(back) back.setBody(StationaryBody()) back.setName("back boundary") back.body.addCollider(Plane(normal=(0, 0, -1), distance= -bounds[1][2])) bottom = yield area.newItem((0, 0, 0), ClassGenerator( "mv3d.server.model.physical.BasicPhysicalObject")) bottom = yield self.sim.getItem(bottom) bottom.setBody(StationaryBody()) bottom.setName("bottom boundary") bottom.body.addCollider(Plane(normal=(0, 1, 0), distance=bounds[0][1])) for obj in [left, right, front, back, bottom]: obj.grantPermission("read", "all") obj.grantPermission("reference", "all") obj.body.grantPermission("read", "all") obj.body.grantPermission("reference", "all") class AssetCreator(object): """ Just a class to hold any information about useful assets that we may need to keep. """ baseUrl = u"http://download.mv3d.com/resources/" colormap = None grass = None cubeasset = None terrainmaterials = None skyassets = None pandaassets = None def __init__(self, conductor, assetgrp): self.playerassets = [] self.trees = [] self.assetgrp = assetgrp self.conductor = conductor self.pandaassets = {} @inlineCallbacks def makeTerrainMaterials(self): """ let's make some cool terrain materials """ t1 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/TestAlpha1.png", ["materials", "textures", "TestAlpha1.png"], u"Test Alpha 1") t2 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/TestAlpha2.png", ["materials", "textures", "TestAlpha2.png"], u"Test Alpha 2") t3 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/Grass.jpg", ["materials", "textures", "Grass.jpg"], u"Grass") t4 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/Dirt.jpg", ["materials", "textures", "Dirt.jpg"], u"Dirt") t5 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/RoughRock.jpg", ["materials", "textures", "RoughRock.jpg"], u"Rough Rock") mat = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/terrain.material", u"Material/TerrainTest", ["materials", "scripts", "terrain.material"], u"Terrain Material", [t1, t2, t3, t4, t5]) self.terrainmaterials = [mat] self.pandaassets["grass"] = t3 @inlineCallbacks def makeCubeAssets(self): """ Make the cube related assets """ self.cubeasset = yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/cube.mesh", [u"models", u"cube.mesh"], u"Cube Mesh") @inlineCallbacks def makeArmoredSwordman(self): """ Make assets related to the armored swordman """ texture = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/armored_swordman.tga", [u"armored_swordman.tga"], u"Body Texture") material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/armored_swordman.material", u"", [u"armored_swordman.material"], u"swordman Material", [texture]) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/armored_swordman.skeleton", [u"armored_swordman.skeleton"], u"swordman Skeleton") mesh = yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/armored_swordman.mesh", [u"Models", u"armored_swordman.mesh"], u"swordman Mesh", [material, skel]) self.playerassets.append({u"name":"armored_swordman", u"models":[mesh], u"scale":(0.02, 0.02, 0.02), "controller":self.compmaster}) @inlineCallbacks def makeTreeAssets(self): """ Make assets for trees """ plant = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/PLANTS09.JPG", ["materials", "textures", "PLANTS09.JPG"], u"plants09") leaves = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/LEAFS.png", ["materials", "textures", "LEAFS.png"], u"leafs") material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/birch.material", u"", [u"birch.material"], u"birch", [leaves, plant]) birch = yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/birch.mesh", [u"models", u"birch.mesh"], u"Birch Tree", [material]) yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + "models/birch.obj", ["models", "birch.obj"], "birch-obj") yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + "models/birch.solid", ["models", "birch.solid"], "birch-solid") self.trees.append(birch.getID()) @inlineCallbacks def makeGrassAssets(self): """ Make assets for grass and vegetation """ grass1 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/grass2.png", ["materials", "textures", "grass2.png"], u"grass2") grass2 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/fgrass1_v2_256.png", ["materials", "textures", "fgrass1_v2_256.png"], u"fgrass1_v2_256") grass3 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/tall_grass.png", ["materials", "textures", "tall_grass.png"], u"tall_grass") self.grass = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/grass.material", u"tall_grass4", [u"grass.material"], u"tall_grass4", [grass1, grass2, grass3]) self.colormap = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/colormap.png", ["materials", "textures", "colormap.png"], u"colormap") @inlineCallbacks def makeNinjaAssets(self): """ Make the ninja player model """ texture = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/ninja.jpg", [u"ninja.jpg"], u"Ninja Texture") material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/ninja2.material", u"", ["ninja2.material"], u"Ninja2 Material", [texture]) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/ninja2.skeleton", [u"ninja2.skeleton"], u"Ninja2 Skeleton") mesh = yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/ninja2.mesh", [u"ninja2.mesh"], u"Ninja2 Mesh", [skel, material]) self.playerassets.append({u"name":"ninja2", u"models":[mesh], u"scale":(0.025, 0.025, 0.025), u"offset":[(0, -0.5, 0), (1, 0, 0, 0)], "controller":self.compmaster}) @inlineCallbacks def makeRobotAssets(self): """ Add assets for the robot player model """ texture = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/r2skin.jpg", [u"r2skin.jpg"], u"robot1 Texture") material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/robot1.material", u"", ["robot1.material"], u"robot1 Material", [texture]) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/robot1.skeleton", [u"robot1.skeleton"], u"robot1 Skeleton") mesh = yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/robot1.mesh", [u"robot1.mesh"], u"robot1 Mesh", [material, skel]) self.playerassets.append({u"name":"robot", u"models":[mesh], u"scale":(0.025, 0.025, 0.025), "controller":self.compmaster}) @inlineCallbacks def makeDragonAssets(self): """ Add assets for the dragon player model """ texture = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/dragon.jpg", [u"dragon.jpg"], u"Dragon Texture") material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/dragon1.material", u"", [u"dragon1.material"], u"Dragon1 Material", [texture]) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/dragon1.skeleton", [u"dragon1.skeleton"], u"Dragon1 Skeleton") mesh = yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/dragon1.mesh", [u"dragon1.mesh"], u"Dragon1 Mesh", [material, skel]) self.playerassets.append({u"name":"dragon", u"models":[mesh], u"scale":(0.02, 0.02, 0.02), "controller":self.compmaster}) @inlineCallbacks def makePointer(self): """ Add assets for the ige pointer model """ texture = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/selector.png", [u"materials", u"textures", u"selector.png"], u"Pointer Texture") material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/pointer.material", u"pointerMaterial", [u"materials", u"scripts", u"pointer.material"], u"Pointer Material", [texture]) yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/pointer.mesh", [u"models", u"pointer.mesh"], u"Pointer Mesh", [material]) @inlineCallbacks def makeSkyAssets(self): """ Make the assets used for caelum """ clearsky = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/EarthClearSky2.png", [u"EarthClearSky2.png"], u"Sky texture") atmos = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/AtmosphereDepth.png", [u"AtmosphereDepth.png"], u"AtmosphereDepth texture") sungrad = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/SunGradient.png", [u"SunGradient.png"], u"Sun gradient texture") shaders = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/programs/CaelumShaders.cg", [u"CaelumShaders.cg"], u"CaelumShaders cg") cloudcg = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/programs/LayeredCloud.cg", [u"LayeredCloud.cg"], u"LayeredCloud cg") noise1 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/noise1.png", [u"noise1.png"], u"noise1 texture") noise2 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/noise2.png", [u"noise2.png"], u"noise2 texture") noise3 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/noise3.png", [u"noise3.png"], u"noise3 texture") noise4 = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/noise4.png", [u"noise4.png"], u"noise4 texture") clouds = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/LayeredClouds.material", u"", [u"LayeredClouds.material"], u"LayeredClouds Material", [cloudcg, noise1, noise2, noise3, noise4]) stars = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/Starfield.jpg", [u"Starfield.jpg"], u"starfield.jpg texture") sphere = yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/sphere.mesh", [u"sphere.mesh"], u"sphere Mesh", []) self.skyassets = [clearsky, sungrad, sphere, shaders, clouds, stars, atmos] @inlineCallbacks def makeWaterAssets(self): """ Make the assets needed for the water """ noise = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/NoiseVolume.dds", [u"NoiseVolume.dds"], u"Noise texture") frag = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/programs/oceanHLSL_Cg_Rtt.frag", [u"oceanHLSL_Cg_Rtt.frag"], u"oceanHLSL_Cg_Rtt fragment") vert = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/programs/oceanHLSL_Cg_Rtt.vert", [u"oceanHLSL_Cg_Rtt.vert"], u"oceanHLSL_Cg_Rtt vertex") material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/Ocean_rtt.material", u"", [u"Ocean_rtt.material"], u"Ocean_rtt Material", [noise, frag, vert]) self.waterassets = [material] @inlineCallbacks def makePandaAssets(self): """ Make the assets needed for the panda demo world. """ aliceTexture = yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/textures/aliceliddell.tif", ["materials", "textures", "aliceliddell.tif"], u"Alice texture") self.pandaassets["aliceTexture"] = aliceTexture alice = yield newURLPandaMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/AliceLiddell.egg", ["models", "AliceLiddell.egg"], "AliceLiddell", [aliceTexture]) self.pandaassets["alice"] = alice ground = yield newURLPandaMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/ground.egg", ["models", "ground.egg"], "Ground", [self.pandaassets["grass"]]) self.pandaassets["ground"] = ground solidGround = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/ground.rxml", ["models", "ground.rxml"], u"ground solid", [ground]) self.pandaassets["solidGround"] = solidGround self.playerassets.append({u"name":"Panda Player", u"models":[alice], u"scale":(0.2, 0.2, 0.2), u"offset":[(0, -2.5, 0), Quaternion.fromEuler((0, 3.14, 0))], "controller":self.compmaster}) @inlineCallbacks def makeArmoredFemaleAssets(self): """ Make assets for the armored female model. """ textures = [] textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_avtbras.png", ["materials", "textures", "GE_HOF_armor04_avtbras.png"], "GE_HOF_armor04_avtbras.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_bras.png", ["materials", "textures", "GE_HOF_armor04_bras.png"], "GE_HOF_armor04_bras.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_cuisse_arr.png", ["materials", "textures", "GE_HOF_armor04_cuisse_arr.png"], "GE_HOF_armor04_cuisse_arr.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_cuisse_avt.png", ["materials", "textures", "GE_HOF_armor04_cuisse_avt.png"], "GE_HOF_armor04_cuisse_avt.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_dos.png", ["materials", "textures", "GE_HOF_armor04_dos.png"], "GE_HOF_armor04_dos.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_hand_downside.png", ["materials", "textures", "GE_HOF_armor04_hand_downside.png"], "GE_HOF_armor04_hand_downside.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_hand_upsideside.png", ["materials", "textures", "GE_HOF_armor04_hand_upsideside.png"], "GE_HOF_armor04_hand_upsideside.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_molet.png", ["materials", "textures", "GE_HOF_armor04_molet.png"], "GE_HOF_armor04_molet.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_pieds.png", ["materials", "textures", "GE_HOF_armor04_pieds.png"], "GE_HOF_armor04_pieds.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/GE_HOF_armor04_torso.png", ["materials", "textures", "GE_HOF_armor04_torso.png"], "GE_HOF_armor04_torso.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/MA_HOF_cheveux_basic01.png", ["materials", "textures", "MA_HOF_cheveux_basic01.png"], "MA_HOF_cheveux_basic01.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/MA_HOF_visage_C1.png", ["materials", "textures", "MA_HOF_visage_C1.png"], "MA_HOF_visage_C1.png"))) textures.append((yield newURLImageAsset(self.conductor, self.assetgrp, self.baseUrl + "materials/textures/MA_HOF_visage_makeup00.png", ["materials", "textures", "MA_HOF_visage_makeup00.png"], "MA_HOF_visage_makeup00.png"))) material = yield newURLOgreMaterialAsset(self.conductor, self.assetgrp, self.baseUrl + u"materials/scripts/femalearmor.material", u"", ["materials", "scripts", "femalearmor.material"], u"femalearmor Material", textures) female = yield newURLPandaMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/female.egg", ["models", "female.egg"], "female", textures) self.pandaassets["female"] = female meshes = [] skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_armpad.skeleton", ["models", "GE_HOF_armor04_armpad.skeleton"], u"GE_HOF_armor04_armpad Skeleton") meshes.append((yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_armpad.mesh", ["models", "GE_HOF_armor04_armpad.mesh"], "GE_HOF_armor04_armpad Mesh", [skel, material]))) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_bottes.skeleton", ["models", "GE_HOF_armor04_bottes.skeleton"], u"GE_HOF_armor04_bottes Skeleton") meshes.append((yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_bottes.mesh", ["models", "GE_HOF_armor04_bottes.mesh"], "GE_HOF_armor04_bottes Mesh", [skel, material]))) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_gilet.skeleton", ["models", "GE_HOF_armor04_gilet.skeleton"], u"GE_HOF_armor04_gilet Skeleton") meshes.append((yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_gilet.mesh", ["models", "GE_HOF_armor04_gilet.mesh"], "GE_HOF_armor04_gilet Mesh", [skel, material]))) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_hand.skeleton", ["models", "GE_HOF_armor04_hand.skeleton"], u"GE_HOF_armor04_hand Skeleton") meshes.append((yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_hand.mesh", ["models", "GE_HOF_armor04_hand.mesh"], "GE_HOF_armor04_hand Mesh", [skel, material]))) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_pantabottes.skeleton", ["models", "GE_HOF_armor04_pantabottes.skeleton"], u"GE_HOF_armor04_pantabottes Skeleton") meshes.append((yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/GE_HOF_armor04_pantabottes.mesh", ["models", "GE_HOF_armor04_pantabottes.mesh"], "GE_HOF_armor04_pantabottes Mesh", [skel, material]))) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/MA_HOF_cheveux_basic01.skeleton", ["models", "MA_HOF_cheveux_basic01.skeleton"], u"MA_HOF_cheveux_basic01 Skeleton") meshes.append((yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/MA_HOF_cheveux_basic01.mesh", ["models", "MA_HOF_cheveux_basic01.mesh"], "MA_HOF_cheveux_basic01 Mesh", [skel, material]))) skel = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/MA_HOF_visage.skeleton", ["models", "MA_HOF_visage.skeleton"], u"MA_HOF_visage Skeleton") meshes.append((yield newURLOgreMeshAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/MA_HOF_visage.mesh", ["models", "MA_HOF_visage.mesh"], "MA_HOF_visage Mesh", [skel, material]))) rep = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"models/femalearmor.rxml", ["models", "femalearmor.rxml"], u"femalearmor.rxml", meshes) self.playerassets.append({u"name":"female", u"models":[rep], u"scale":(1, 1, 1), u"offset":[(0, -0.5, 0), (1, 0, 0, 0)], "controller":self.compmaster}) self.playerassets.append({u"name":"Panda Female Player", u"models":[ female], u"scale":(1, 1, 1), u"offset":[(0, 0, 0), Quaternion.fromEuler((0, 0, 0))], "controller":self.compmaster}) @inlineCallbacks def addAssets(self): """ Add all the assets to the server """ log.msg("Building assets.") self.compmaster = yield newURLFileAsset(self.conductor, self.assetgrp, self.baseUrl + u"player.xml", ["models", "player.xml"], u"player.xml") yield self.makeTerrainMaterials() yield self.makeCubeAssets() yield self.makeArmoredSwordman() yield self.makeTreeAssets() yield self.makeGrassAssets() yield self.makeNinjaAssets() yield self.makeRobotAssets() yield self.makeDragonAssets() yield self.makeSkyAssets() yield self.makeWaterAssets() yield self.makePointer() yield self.makePandaAssets() yield self.makeArmoredFemaleAssets() log.msg("Finished building assets.")