def main():
conny_tank = tank.Tank('German', 'Tiger')
thomas_tank = tank.Tank('America', 'Sherman')
lasse_tank = tank.Tank('Brish', 'Churchill')
conny_tank.accel(38)
thomas_tank.accel(29)
lasse_tank.rotate_left(320)
lasse_tank.shoot()
conny_tank.take_damage(63)
thomas_tank.take_damage(34)
print(
f"Conny's tank is at {conny_tank.origin} and health is {conny_tank._health}"
)
print(f"The health of conny's and thomas's is {conny_tank + thomas_tank}")
print(dir(tank))
if hasattr(tank, '__str__'):
print("tank has str")
if hasattr(thomas_tank, '__str__'):
print(f"Status of thomas_tank: {thomas_tank}")
#thomas_tank.set_health(100)
#print(f"Health of thomas_tank: {thomas_tank.get_health()}")
thomas_tank.tank_health = 99
print(f"Health of thomas_tank: {thomas_tank.tank_health}")
def __init__(self, width=1200, height=675):
pg.init()
pg.mixer.init()
self.width = width
self.height = height
self.screen = pg.display.set_mode((self.width, self.height))
pg.display.set_caption("Tanks")
pg.display.update()
self.background = u.loadImage("myBackground.png")[0]#pg.Surface(self.screen.get_size()).convert()
self.screen.blit(self.background, (0, 0))
self.wall = u.loadImage("myWall.png")
self.screen.blit(self.wall[0],(600,375))
self.tank1 = tank.Tank(10, u.GROUND, "myTank.png", "myShootyThing45.png",1)
self.screen.blit(self.tank1.image, (100, 577))
self.screen.blit(self.tank1.shootyThingImage, (0, 0))
self.tank2 = tank.Tank(-10, u.GROUND, "myTank2.png", "myShootyThing2_45.png",2)
self.screen.blit(self.tank2.image, (1100, 577))
self.screen.blit(self.tank2.shootyThingImage, (0, 0))
self.spritegroup = pg.sprite.Group()
self.smallfont = pg.font.SysFont("comicsansms",25)
self.medfont = pg.font.SysFont("comicsansms",50)
self.largefont = pg.font.SysFont("comicsansms",80)
self.music = u.loadMusic("IntroMusic.mp3")
#self.icon = pg.image.load('myTank.png')
pg.sprite.RenderPlain()
pg.display.flip()
#pg.display.set_icon(self.icon)#best size is 32*32
self.clock = pg.time.Clock()
self.buttong = pg.draw.rect(self.screen,u.GREEN,(100,500,100,50))
self.buttony = pg.draw.rect(self.screen,u.YELLOW,(300,500,100,50))
self.buttonr = pg.draw.rect(self.screen,u.RED,(500,500,100,50))
def test_project_root_mismatch(self):
"""
Case that root name specified in projects yml file does not exist in roots file.
"""
# remove root name from the roots file
self.setup_multi_root_fixtures()
self.tk = tank.Tank(self.project_root)
# should be fine
folder.configuration.FolderConfiguration(self.tk, self.schema_location)
roots_file = os.path.join(self.tk.pipeline_configuration.get_path(),
"config", "core", "schema",
"alternate_1.yml")
fh = open(roots_file, "r")
data = yaml.load(fh)
fh.close()
data["root_name"] = "some_bogus_Data"
fh = open(roots_file, "w")
fh.write(yaml.dump(data))
fh.close()
self.tk = tank.Tank(self.project_root)
self.assertRaises(TankError, folder.configuration.FolderConfiguration,
self.tk, self.schema_location)
def __init__(self, width=1200, height=675):
pg.init()
pg.mixer.init()
self.width = width
self.height = height
self.screen = pg.display.set_mode((self.width, self.height))
pg.display.set_caption("Tanks")
pg.display.update()
self.background = u.loadImage("myBackground.png")[
0] #pg.Surface(self.screen.get_size()).convert()
self.screen.blit(self.background, (0, 0))
self.wall = u.loadImage("theBarrierReal.jpg")[0]
self.screen.blit(self.wall, (600, 0))
self.tank1 = tank.Tank(10, u.GROUND, "myTank.png",
"myShootyThing45.png", 1, 1)
self.screen.blit(self.tank1.image, (100, 577))
self.screen.blit(self.tank1.shootyThingImage, (0, 0))
#self.tank2 = tank.Tank(-10, u.GROUND, "myTank2.py", "myShootyThing2_45.png",2, 1)
self.tank2 = tank.Tank(-10, u.GROUND, "trumpsan.png",
"myShootyThing2_45.png", 2, 3)
self.screen.blit(self.tank2.image, (1100, 577))
#self.screen.blit(self.tank2.shootyThingImage, (0, 0))
self.spritegroup = pg.sprite.Group()
self.smallfont = pg.font.SysFont("japan", 25)
self.medfont = pg.font.SysFont("japan", 50)
self.largefont = pg.font.SysFont("electron", 80)
#self.music = u.loadMusic("IntroMusic.mp3")
self.music = u.loadMusic("RealGameMusic.mp3")
pg.sprite.RenderPlain()
pg.display.flip()
self.clock = pg.time.Clock()
self.buttong = pg.draw.rect(self.screen, u.GREEN, (100, 500, 100, 50))
self.buttony = pg.draw.rect(self.screen, u.YELLOW, (300, 500, 100, 50))
self.buttonr = pg.draw.rect(self.screen, u.RED, (500, 500, 100, 50))
def setUp(self):
super(TestCreateFilesystemStructure, self).setUp()
self.setup_fixtures()
self.tk = tank.Tank(self.project_root)
self.seq = {
"type": "Sequence",
"id": 2,
"code": "seq_code",
"project": self.project
}
self.shot = {
"type": "Shot",
"id": 1,
"code": "shot_code",
"sg_sequence": self.seq,
"project": self.project
}
self.step = {
"type": "Step",
"id": 3,
"code": "step_code",
"short_name": "step_short_name"
}
self.asset = {
"type": "Asset",
"id": 4,
"sg_asset_type": "assettype",
"code": "assetname",
"project": self.project
}
self.task = {
"type": "Task",
"id": 1,
"content": "this task",
"entity": self.shot,
"step": {
"type": "Step",
"id": 3
},
"project": self.project
}
# Add these to mocked shotgun
self.add_to_sg_mock_db([
self.shot, self.seq, self.step, self.project, self.asset, self.task
])
self.tk = tank.Tank(self.project_root)
# add mock schema data so that a list of the asset type enum values can be returned
data = {}
data["properties"] = {}
data["properties"]["valid_values"] = {}
data["properties"]["valid_values"]["value"] = ["assettype"]
data["data_type"] = {}
data["data_type"]["value"] = "list"
self.add_to_sg_schema_db("Asset", "sg_asset_type", data)
def init_game(windowsize, count):
gmap = mymap.Map(windowsize)
if mapfile:
gmap.set_map(mapfile)
else:
gmap.random_map()
player = tank.Tank(True, gmap, count)
enemynum = random.randint(1, 10)
enemies = []
for i in range(enemynum):
count += 1
enemies.append(tank.Tank(False, gmap, count))
return gmap, player, enemies
def setUp(self):
"""Sets up entities in mocked shotgun database and creates Mock objects
to pass in as callbacks to Schema.create_folders. The mock objects are
then queried to see what paths the code attempted to create.
"""
super(TestSchemaCreateFoldersSecondaryEntity, self).setUp()
self.setup_fixtures("optional_folder_fields")
self.shot = {
"type": "Shot",
"id": 1,
"code": "shot_code",
"sg_other_field": None,
"project": self.project
}
entities = [self.shot, self.project]
# Add these to mocked shotgun
self.add_to_sg_mock_db(entities)
self.tk = tank.Tank(self.project_root)
self.schema_location = os.path.join(self.project_root, "tank",
"config", "core", "schema")
self.FolderIOReceiverBackup = folder.folder_io.FolderIOReceiver.execute_folder_creation
folder.folder_io.FolderIOReceiver.execute_folder_creation = execute_folder_creation_proxy
def setUp(self):
super(TestEnvironment, self).setUp()
self.setup_fixtures()
self.test_env = "test"
self.test_engine = "test_engine"
# create env object
tk = tank.Tank(self.project_root)
self.env = tk.pipeline_configuration.get_environment(self.test_env)
# get raw environment
env_file = os.path.join(self.project_config, "env", "test.yml")
fh = open(env_file)
self.raw_env_data = yaml.load(fh)
fh.close()
# get raw app metadata
app_md = os.path.join(self.project_config, "test_app", "info.yml")
fh = open(app_md)
self.raw_app_metadata = yaml.load(fh)
fh.close()
# get raw engine metadata
eng_md = os.path.join(self.project_config, "test_engine", "info.yml")
fh = open(eng_md)
self.raw_engine_metadata = yaml.load(fh)
fh.close()
def setUp(self):
super(TestValidateSettings, self).setUp()
# set up data so as to supply a valid context
seq = {"type": "Sequence", "name": "seq_name", "id": 3}
seq_path = os.path.join(self.project_root, "sequence/Seq")
self.add_production_path(seq_path, seq)
shot = {
"type": "Shot",
"name": "shot_name",
"id": 2,
"project": self.project
}
shot_path = os.path.join(seq_path, "shot_code")
self.add_production_path(shot_path, shot)
# a second shot path without sequence
shot_path_2 = os.path.join(self.project_root, "shot_code")
self.add_production_path(shot_path_2, shot)
# setup context with values for project and shot
self.tk = tank.Tank(self.project_root)
self.context = self.tk.context_from_path(shot_path)
# The validation code needs a name for error reporting
self.app_name = "test_app"
# keys for templates
self.keys = {
"Sequence": StringKey("Sequence"),
"Shot": StringKey("Shot")
}
def test_skip_invalid(self):
"""Test that files not valid for an template are not returned.
This refers to bug reported in Ticket #17090
"""
keys = {
"Shot": StringKey("Shot"),
"Sequence": StringKey("Sequence"),
"Step": StringKey("Step"),
"name": StringKey("name"),
"version": IntegerKey("version", format_spec="03")
}
definition = "sequences/{Sequence}/{Shot}/{Step}/work/{name}.v{version}.nk"
template = TemplatePath(definition, keys, self.project_root,
"my_template")
tk = tank.Tank(self.project_root)
tk._templates = {template.name: template}
bad_file_path = os.path.join(self.project_root, "sequences",
"Sequence1", "Shot1", "Foot", "work",
"name1.va.nk")
good_file_path = os.path.join(self.project_root, "sequences",
"Sequence1", "Shot1", "Foot", "work",
"name.v001.nk")
self.create_file(bad_file_path)
self.create_file(good_file_path)
ctx_fields = {"Sequence": "Sequence1", "Shot": "Shot1", "Step": "Foot"}
result = tk.paths_from_template(template, ctx_fields)
self.assertIn(good_file_path, result)
self.assertNotIn(bad_file_path, result)
def create_tanks(self, num_tanks):
# Populate a list based on number of tanks
# The list will be useful for keeping track of all of the tanks, and
# being able to do the same operation (such a "draw") on them all very
# easily.
self.tanksList = []
for n in range(1, num_tanks + 1):
new_tank = tank.Tank(name=f"Player {n}",
parent=self,
position=pymunk.Vec2d(
WindowConfig.WIDTH * n / (num_tanks + 1),
WindowConfig.HEIGHT / 3),
color=next(TankConfig.COLORS))
self.tanksList.append(new_tank)
# Create a circular Iterator for the tank list
# An Iterator is something different from a list, though certainly you can
# "iterate" through things like lists and tuples and even dictionaries.
# In other words, lists and tuples and dictionaries can themselves be termed
# "Iterators". I still want a list of tanks, but I also want something that
# points to that list, but I can use to cycle through them endlessly. I know
# that I want this, because I know that I just want to be able to keep going
# to whatever Tank's turn is next. Next, next, next. Me calling "next" shouldn't
# alter the list of tanks; I can have two "views" of the same data: the list
# view, and the endless cycle view.
self.tanksCycle = itertools.cycle(self.tanksList)
# Set the active player
self.activeTank = next(self.tanksCycle)
def setUp(self):
super(TestStaticFolderFilters, self).setUp()
self.setup_fixtures("static_filters_core")
self.tk = tank.Tank(self.project_root)
self.shot_aaa = {
"type": "Shot",
"id": 1,
"code": "aaa",
"project": self.project
}
self.shot_bbb = {
"type": "Shot",
"id": 2,
"code": "bbb",
"project": self.project
}
self.add_to_sg_mock_db([self.shot_aaa, self.shot_bbb])
self.aaa = os.path.join(self.project_root, "aaa")
self.aaa_work = os.path.join(self.project_root, "aaa", "work")
self.aaa_pub = os.path.join(self.project_root, "aaa", "publish")
self.bbb = os.path.join(self.project_root, "bbb")
self.bbb_work = os.path.join(self.project_root, "bbb", "work")
self.bbb_pub = os.path.join(self.project_root, "bbb", "publish")
def test_sequence_abstracted_path(self):
"""Test that if path supplied represents a sequence, the abstract version of that
sequence is used."""
tk = tank.Tank(self.project_root)
# mock shotgun
tk._tank__sg = self.sg_mock
# make sequence key
keys = {"seq": tank.templatekey.SequenceKey("seq", format_spec="03")}
# make sequence template
seq_template = tank.template.TemplatePath("/folder/name_{seq}.ext",
keys, self.project_root)
tk.templates["sequence_template"] = seq_template
seq_path = os.path.join(self.project_root, "folder", "name_001.ext")
# mock sg.create, check it for path value
tank.util.register_publish(tk, self.context, seq_path, self.name,
self.version)
# check that path is modified before sent to shotgun
expected_path = os.path.join(self.project_root, "folder",
"name_%03d.ext")
project_name = os.path.basename(self.project_root)
expected_path_cache = "%s/%s/%s" % (project_name, "folder",
"name_%03d.ext")
# look at values sent to the Mocked shotgun.create
actual_path = tk.shotgun.create.call_args[0][1]["path"]["local_path"]
actual_path_cache = tk.shotgun.create.call_args[0][1]["path_cache"]
self.assertEqual(expected_path, actual_path)
self.assertEqual(expected_path_cache, actual_path_cache)
def setUp(self):
super(TestApplication, self).setUp()
self.setup_fixtures()
# setup shot
seq = {"type": "Sequence", "name": "seq_name", "id": 3}
seq_path = os.path.join(self.project_root, "sequences/Seq")
self.add_production_path(seq_path, seq)
shot = {
"type": "Shot",
"name": "shot_name",
"id": 2,
"project": self.project
}
shot_path = os.path.join(seq_path, "shot_code")
self.add_production_path(shot_path, shot)
step = {"type": "Step", "name": "step_name", "id": 4}
self.shot_step_path = os.path.join(shot_path, "step_name")
self.add_production_path(self.shot_step_path, step)
self.test_resource = os.path.join(self.project_root, "tank", "config",
"foo", "bar.png")
os.makedirs(os.path.dirname(self.test_resource))
fh = open(self.test_resource, "wt")
fh.write("test")
fh.close()
tk = tank.Tank(self.project_root)
context = tk.context_from_path(self.shot_step_path)
self.engine = tank.platform.start_engine("test_engine", tk, context)
def start(self):
_dispaly.init()
MainGame.window = _dispaly.set_mode([SCREEN_WIDTH, SCREEN_HEIGT])
_dispaly.set_caption("坦克又见坦克")
self.music.playbgm(bgmFile='img/start.wav')
# 加载我方坦克
MainGame.TANK_P1 = tank.Tank(MainGame.window, 400, 300)
# 加载敌方坦克
self.creatEnemyTank()
self.creatWalls()
# 循环刷新窗体
while True:
# 不循环事件会卡住
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit(0) # 0正常退出程序
else:
self.doneEvent(event)
MainGame.window.fill(COLOR_BG)
if len(MainGame.EnemyTanks) == 0:
x = random.randint(10, 700)
y = random.randint(10, 500)
MainGame.window.blit(
self.getTextSurface("You Win Press 'R' Restart"), (x, y))
time.sleep(1)
_dispaly.update()
continue
if not MainGame.TANK_P1.live:
x = random.randint(10, 700)
y = random.randint(10, 500)
MainGame.window.blit(
self.getTextSurface("You Loss Press 'R' Restart"), (x, y))
time.sleep(1)
_dispaly.update()
continue
MainGame.window.blit(
self.getTextSurface(u"Remain %d Tankers" %
len(MainGame.EnemyTanks)), (5, 5))
if MainGame.TANK_P1.live:
MainGame.TANK_P1.displayTank()
MainGame.TANK_P1.hitWalls(MainGame.Walls)
MainGame.TANK_P1.hitTank(MainGame.EnemyTanks, MainGame.TANK_P1)
self.blitWalls()
self.blitEnemyTank()
self.blitBullets()
self.blitExploads()
#根据坦克的开关状态调用坦克的移动方法
if MainGame.TANK_P1 and not MainGame.TANK_P1.stop:
MainGame.TANK_P1.move()
time.sleep(0.02)
_dispaly.update()
def setUp(self):
super(TestFolderCreationEdgeCases, self).setUp()
self.setup_fixtures()
self.tk = tank.Tank(self.project_root)
self.seq = {
"type": "Sequence",
"id": 2,
"code": "seq_code",
"project": self.project
}
self.shot = {
"type": "Shot",
"id": 1,
"code": "shot_code",
"sg_sequence": self.seq,
"project": self.project
}
self.step = {
"type": "Step",
"id": 3,
"code": "step_code",
"short_name": "step_short_name"
}
self.task = {
"type": "Task",
"id": 1,
"content": "this task",
"entity": self.shot,
"step": {
"type": "Step",
"id": 3
},
"project": self.project
}
# Add these to mocked shotgun
self.add_to_sg_mock_db(
[self.shot, self.seq, self.step, self.project, self.task])
self.tk = tank.Tank(self.project_root)
self.path_cache = path_cache.PathCache(self.tk.pipeline_configuration)
def setUp(self):
"""Sets up entities in mocked shotgun database and creates Mock objects
to pass in as callbacks to Schema.create_folders. The mock objects are
then queried to see what paths the code attempted to create.
"""
super(TestSchemaCreateFoldersStepAndUserSandbox, self).setUp()
self.setup_fixtures("humanuser_step_core")
self.seq = {
"type": "Sequence",
"id": 2,
"code": "seq_code",
"project": self.project
}
self.shot = {
"type": "Shot",
"id": 1,
"code": "shot_code",
"sg_sequence": self.seq,
"project": self.project
}
self.step = {
"type": "Step",
"id": 3,
"code": "step_code",
"short_name": "step_short_name"
}
self.task = {
"type": "Task",
"id": 23,
"entity": self.shot,
"step": self.step,
"project": self.project
}
cur_login = tank.util.login.get_login_name()
self.humanuser = {"type": "HumanUser", "id": 2, "login": cur_login}
entities = [
self.shot, self.task, self.seq, self.step, self.project,
self.humanuser
]
# Add these to mocked shotgun
self.add_to_sg_mock_db(entities)
self.tk = tank.Tank(self.project_root)
self.schema_location = os.path.join(self.project_root, "tank",
"config", "core", "schema")
self.FolderIOReceiverBackup = folder.folder_io.FolderIOReceiver.execute_folder_creation
folder.folder_io.FolderIOReceiver.execute_folder_creation = execute_folder_creation_proxy
def setUpThread():
global CLOCK
global playerReady, Bullet
global waitFlag
global team1, team2
for F in playerName.keys():
Bullet[F] = None
for F in playerName.keys():
playerDead[F] = 0
for F in playerName.keys():
playerReady[F] = 0
team1, team2 = utilites.shuffle(playerName)
for F in team1.keys():
team1[F] = tank.Tank(playerName[F], utilites.teamSide(0), -110 + setting.HEIGHT, -1)
for F in team2.keys():
team2[F] = tank.Tank(playerName[F], utilites.teamSide(1), -110 + setting.HEIGHT, 1)
CLOCK = clockThread()
time.sleep(5)
CLOCK.start()
def setUp(self):
super(TestUpdateEnvironment, self).setUp()
self.setup_fixtures()
self.test_env = "test"
self.test_engine = "test_engine"
# create env object
tk = tank.Tank(self.project_root)
self.env = tk.pipeline_configuration.get_environment(self.test_env)
def test_good_path(self):
app_path = os.path.join(self.project_config, "test_app")
tk = tank.Tank(self.project_root)
# make a dev location and create descriptor
app_desc = descriptor.get_from_location(descriptor.AppDescriptor.APP,
tk.pipeline_configuration, {
"type": "dev",
"path": app_path
})
result = application.get_application(self.engine, app_path, app_desc,
{}, "instance_name")
self.assertIsInstance(result, application.Application)
class GameWindow(pyglet.window.Window):
def __init__(self, *arg, **kwargs):
super().__init__(*arg, **kwargs)
player_tank = []
piece_of_tank = {}
tank_1 = tank.Tank(240, 300)
tu = turret.Turret(tank_1.x, tank_1.y)
ch = chassis.Chassis(tank_1.x, tank_1.y)
# Dict des instances du tank
piece_of_tank['tank'] = tank_1
piece_of_tank['turret'] = tu
piece_of_tank['chassis'] = ch
# Creation des sprites
chassis_1 = ch.create_chassis('assets/sprites/chassis_2.png')
turret_1 = tu.create_turret("assets/sprites/turret_2.png")
# liste des sprites
player_tank.append(chassis_1)
player_tank.append(turret_1)
def on_draw(
self
): # Surcharge la methode de on_draw de la superclass pyglet.window.Window
self.clear()
# boucle sur liste des sprites
for t in self.player_tank:
t.draw()
def on_mouse_motion(self, x, y, dx, dy):
self.mouse_x = int(float(x))
self.mouse_y = int(float(y))
def on_key_press(self, symbol, modifiers):
self.player.isKeyPressed = True
if symbol == key.Z:
self.direction = 'head'
elif symbol == key.S:
self.direction = 'back'
elif symbol == key.D:
self.direction = 'right'
elif symbol == key.Q:
self.direction = 'left'
def on_key_release(self, symbol, modifiers):
self.player.isKeyPressed = False
self.direction = "none"
def update(self, dt):
self.tu.rotate(dt)
def restart(self):
MainGame.EnemyTanks = []
MainGame.Walls = []
MainGame.Bullets = []
MainGame.Exploads = []
MainGame.TANK_P1 = None
self.music.playbgm(bgmFile='img/start.wav')
# 加载我方坦克
MainGame.TANK_P1 = tank.Tank(MainGame.window, 400, 300)
# 加载敌方坦克
self.creatEnemyTank()
self.creatWalls()
def __init__(self, ioloop):
self.ioloop = ioloop
self.serv = server.TopServer(self)
#self.tank = tank.Tank(options.options.tank, 43000)
self.tank = tank.Tank('192.168.1.2', 43000)
self.state = State.RESULTS
self.user = None
self.rps = rps.RPSCounter()
self.top = top.Top()
self.users = users.Userlist()
self.timer_counter = None
self.timer_fn = None
self.timer_cb = tornado.ioloop.PeriodicCallback(self.timer, 1000, self.ioloop)
def changeTank(self):
try:
self.tank = tank.Tank(self.station.stationId)
tankName = self.mainWindow.tankSelect_comboBox.currentText()
fuel_receive_today = self.a_query.received_quantity_for(tankName,self.mainWindow.tank_dateEdit.text())
stockEoPD = self.a_query.end_of_previous_day_volume_for(tankName,self.mainWindow.tank_dateEdit.text())
sales_and_stockEoD = self.a_query.sales_and_stockEoD_for(tankName,self.mainWindow.tank_dateEdit.text())
lost_fuel = self.a_query.calculated_lost_for(tankName,self.mainWindow.tank_dateEdit.text())
self.mainWindow.fuelReceived_doubleSpinBox.setValue(fuel_receive_today)
self.mainWindow.StockBoD_doubleSpinBox.setValue(stockEoPD)
self.mainWindow.sales_doubleSpinBox.setValue(sales_and_stockEoD['sales'])
self.mainWindow.StockEoD_doubleSpinBox.setValue(sales_and_stockEoD['stockEoD'])
self.mainWindow.lost_fuel_doubleSpinBox.setValue(lost_fuel)
except:
self.mainWindow.lost_fuel_doubleSpinBox.setValue(0)
def test_project_one_yml_missing(self):
"""
Case that there are mutiple projects, one non-primary without yaml a file
"""
self.setup_multi_root_fixtures()
self.tk = tank.Tank(self.project_root)
# should be fine
folder.configuration.FolderConfiguration(self.tk, self.schema_location)
project_yml = os.path.join(self.schema_location, "alternate_1.yml")
os.remove(project_yml)
self.assertRaises(TankError, folder.configuration.FolderConfiguration,
self.tk, self.schema_location)
def __tank_startup_node_callback():
"""
Callback that fires every time a node gets created.
Carefully manage exceptions here so that a bug in Tank never
interrupts the normal workflows in Nuke.
"""
try:
# look for the root node - this is created only when a new or existing file is opened.
tn = nuke.thisNode()
if tn != nuke.root():
return
if nuke.root().name() == "Root":
# file->new
# base it on the context we 'inherited' from the prev session
# get the context from the previous session - this is helpful if user does file->new
project_root = os.environ.get("TANK_NUKE_ENGINE_INIT_PROJECT_ROOT")
tk = tank.Tank(project_root)
ctx_yaml = os.environ.get("TANK_NUKE_ENGINE_INIT_CONTEXT")
if ctx_yaml:
try:
new_ctx = yaml.load(ctx_yaml)
except:
new_ctx = tk.context_empty()
else:
new_ctx = tk.context_empty()
else:
# file->open
file_name = nuke.root().name()
try:
tk = tank.tank_from_path(file_name)
except tank.TankError, e:
__create_tank_disabled_menu(e)
return
# try to get current ctx and inherit its values if possible
curr_ctx = None
if tank.platform.current_engine():
curr_ctx = tank.platform.current_engine().context
new_ctx = tk.context_from_path(file_name, curr_ctx)
# now restart the engine with the new context
__engine_refresh(tk, new_ctx)
def test_context_determines_fields(self):
"""
Case that field has no direct value in the context, but does have a value
when calling Context.as_template_fields.
"""
# template with fields not in required fields or context's attributes
field_name = "Sequence"
template = tank.template.TemplatePath("sequence/{%s}" % field_name,
self.keys, self.project_root)
# tank instance with this template
tk = tank.Tank(self.project_root)
tk.templates = {self.template_name: template}
# If no error, then success
validate_settings(self.app_name, tk, self.context, self.metadata,
self.config)
def test_fields_from_context(self):
"""
Case that a template's fields that are not part of the metadata's
required fields have value in the context.
"""
# template with fields matching context attributes
field_name = "Shot"
template = tank.template.TemplatePath("{%s}" % field_name, self.keys,
self.project_root)
# tank instance with this template
tk = tank.Tank(self.project_root)
tk.templates = {self.template_name: template}
# If no error, then success
validate_settings(self.app_name, tk, self.context, self.metadata,
self.config)
def test_default_values_detected(self):
"""
Case that field's value cannot be determined by the context, but field has a default value.
"""
# template with field with default value
field_name = "field_1"
self.keys[field_name] = StringKey(field_name, default="default")
template = tank.template.TemplatePath("{%s}" % field_name, self.keys,
self.project_root)
# tank instance with this template
tk = tank.Tank(self.project_root)
tk.templates = {self.template_name: template}
# If no error, then success
validate_settings(self.app_name, tk, self.context, self.metadata,
self.config)
def place_obj_by_index(self, index, x, y):
o = None
if index == game.OBJ['factory']: # Factory
o = factory.Factory(x, y)
self.factories.append(o)
self.game_group.add(o)
self.animatedsprites.append(o)
if index == game.OBJ['cityhall']: # City Hall
o = cityhall.CityHall(x, y)
self.cityhalls.append(o)
self.game_group.add(o)
self.animatedsprites.append(o)
elif index == game.OBJ['police']: # Police
o = police.Police(x, y)
self.game_group.add(o)
self.animatedsprites.append(o)
o.set_starting_dir(self.road_grid)
elif index == game.OBJ['soldier']: # Soldier
o = soldier.Soldier(x, y)
self.game_group.add(o)
self.animatedsprites.append(o)
o.set_starting_dir(self.road_grid)
elif index == game.OBJ['start']: #Starting tile
o = starttile.StartTile(x, y)
self.game_group.add(o)
self.animatedsprites.append(o)
elif index == game.OBJ['celltower']:
o = celltower.CellTower(x, y)
self.game_group.add(o)
self.animatedsprites.append(o)
elif index == game.OBJ['tank']:
o = tank.Tank(x, y)
self.game_group.add(o)
self.animatedsprites.append(o)
self.tanks.append(o)
o.set_starting_dir(self.road_grid)
self.object_grid[y][x] = o
