def run(self):
parser = MovieIdParser(self.moviecount)
parser.run_parser()
fetcher = MovieDataFetcher(parser.idcontainer)
fetcher.run()
sortedmovies = Sorter.sort_by_year(fetcher.fullmoviesdata)
#Save.save_to_csv(sortedmovies, self.file)
Save.save_to_db(sortedmovies)
def __init__(self, mp=Map()):
self.map = mp
self.current_location = Level()
self.msave = {}
if mp != None:
self.msave = mp.info
self.ms = Save(str(mp.get("name")) + ".json")
else:
self.ms = Save("")
def __init__(self, P_Builder):
self.Builder = P_Builder
self.Load = Load()
self.File = File()
self.Save = Save(self.File)
self.Kanban = Kanban()
self.Graphical_Kanban = None
self.action_flag = None
self.Temp_Widget_Reference = None
def results(self, end_results):
self.DEndResults = end_results
if self.listVar.get() == 1:
iteration = 0
for key, element in end_results.items():
self.resultList.insert(iteration, key)
iteration += 1
if self.saveVar.get() == 1:
saving = Save(self.SInstrument, self.DEndResults,
self.SPathForSaving)
saving.start()
def load(self, slot, startlevel=False):
self.slot = slot
s = Save()
data = s.load(slot)
if data is None:
self.levelidx = 0
else:
self.levelidx = data.levelidx
if startlevel:
self.startlevel(self.levelidx, True)
return data
def __init__(self, m):
"""
:param m: Menu
"""
self.levelName = "levelTwo"
self.gameState = ''
m.game = self
self.menu = m
self.setLight()
self.loadScene()
if self.menu.tempPlayer is None:
self.initCollision()
self.initPlayer()
else:
print 'temp not none'
self.node = self.menu.tempPlayer
self.node.node.setPos(-250, 265, 20)
self.node.game = self
self.node.initMission()
self.node.mission.memoryNum = self.menu.tempPlayer.mission.memoryNum
self.enemy = Enemylevel2(self.node)
# self.node.node.setPos(-800, 0, 20)
# self.node.node.setPos(-370, 2800, 25)
self.node.node.setPos(-700, 0, 25)
self.node.node.setHpr(-90, 0, 0)
base.accept("escape", self.pauseGame)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.mutableMap = {}
self.glowFilter()
self.initMania()
self.finalcard.reparentTo(hidden)
self.initBag()
# self.menu.loadState = True
self.menu.passFrame.show()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
if not self.menu.skipUseless:
self.menu.loadState = True
taskMgr.add(self.waitOne, "waitOne")
else:
self.save = Save(self)
if self.menu.selectedSave == 2:
self.save.loadFile('gameinfo_2.save')
elif self.menu.selectedSave == 3:
self.save.loadFile('gameinfo_3.save')
self.node.changeCamera()
self.menu.loadState = True
self.menu.passFrame.hide()
self.setupskillpattern()
class GameFSM(FSM):
def enterStartMenu(self):
self.menu = StartMenu()
def exitStartMenu(self):
self.menu.destroy()
del self.menu
def enterTrain(self):
self.train = TrainingMode()
def exitTrain(self):
self.train.destroy()
del self.train
def enterBattle(self):
self.battle = BattleMode()
def exitBattle(self):
if self.battle.popupText:
self.battle.popupText.detachNode()
self.battle.popupText = None
self.battle.destroy()
del self.battle
def enterControls(self):
self.controls = Controls()
def exitControls(self):
self.controls.destroy()
del self.controls
def enterSave(self):
self.save = Save()
def exitSave(self):
self.save.destroy()
del self.save
def enterLoad(self):
self.load = Load()
def exitLoad(self):
self.load.destroy()
del self.load
def enterStats(self):
self.stats = Stats()
def exitStats(self):
self.stats.destroy()
del self.stats
class Online:
def __init__(self, n, m, depth, save_permission, user_id, team_id,
game_id):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.SLEEP_TIME = 5
self.G = Game(n, m)
self.T = Tree(n, m, depth)
self.API = Api(user_id, team_id)
self.API.set_game_id(game_id)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T.EF.Hash = out
def start_game(self):
# first move: O
side = int(input('choose side\n0: O, 1: X'))
player = 1 if side == 1 else -1
print('Start\n', self.G)
while True:
while True:
players_turn = self.G.input_board_list(self.API.get_board())
if players_turn == player:
break
else:
print('Waiting for Player',
'X' if players_turn == 1 else 'O')
time.sleep(self.SLEEP_TIME)
print(self.G)
t = time.time()
y, x = self.T.search(self.G.get_state() * player)
print('Time:', time.time() - t)
self.API.make_move(y, x)
if self.G.input(y, x, player):
break
# save cache
self.S.save(self.T.EF.Hash)
print('End')
def __init__(self, n, m, depth, save_permission):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.G = Game(n, m)
self.T = Tree(n, m, depth)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T.EF.Hash = out
def do_export(self, args):
filename = None
if args.output:
if os.path.isdir(args.output):
filename = os.path.join(args.output, args.id + ".pak")
else:
filename = args.output
else:
filename = args.id + ".pak"
data = None
json_filename = None
if not args.save_type:
args.save_type = self.filesystem.get_json_filename_type(args.id)
if not args.save_type:
return 1, "Unable to determine type of id %s" % args.id
json_filename = self.filesystem.get_json_filename_for_type(
args.id, args.save_type)
if not json_filename:
return 1, "Unable to find filename for id %s (wrong -s/-w/-c specified?)" % args.id
data = load_json_file(json_filename)
if not data:
return 1, "Unable to load data for file %s" % json_filename
save = Save(savedata=data,
filename=json_filename,
ident=args.id,
save_type=args.save_type,
filesystem=self.filesystem)
if not save.isInstalled:
if not args.download:
return 1, "Unable to find all urls required by %s. Rerun with -d to try and download them or open it within TTS.\n%s" % (
args.id, save)
else:
logger().info("Downloading missing files...")
successful = save.download()
if successful:
logger().info("Files downloaded successfully.")
else:
return 1, "Some files failed to download"
if os.path.isfile(filename) and not args.force:
return 1, "%s already exists. Please specify another file or use '-f'" % filename
logger().info("Exporting json file %s to %s" % (args.id, filename))
save.export(filename)
# TODO: exception handling
return 0, "Exported %s to %s" % (args.id, filename)
def __init__(self, parent, controller, gui):
tk.Frame.__init__(self, parent)
color_bg = "#a2ddf5"
color_active = "#7acef0"
self.parent = parent
self.controller = controller
self.gui = gui
Photo(self, "sprites/battleship_logo.png", 0.3, 0.07, 0.4, 0.2)
button1 = tk.Button(self,
text="New Game",
font=40,
command=self.new_game,
bg=color_bg,
activebackground=color_active)
button1.place(relx=0.4, rely=0.33, relheight=0.15, relwidth=0.2)
game = Save(game=self.gui.game).load()
self.button2 = tk.Button(self,
text="Continue Game",
font=40,
command=lambda: self.continue_game(game),
bg=color_bg,
activebackground=color_active)
self.button2.place(relx=0.4, rely=0.53, relheight=0.15, relwidth=0.2)
if not game:
self.button2.configure(state="disabled")
button3 = tk.Button(
self,
text="Settings",
font=40,
command=lambda: controller.show_frame("SettingsPage"),
bg=color_bg,
activebackground=color_active)
button3.place(relx=0.4, rely=0.73, relheight=0.15, relwidth=0.2)
class Pve:
def __init__(self, n, m, depth, save_permission):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.G = Game(n, m)
self.T = Tree(n, m, depth)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T.EF.Hash = out
def start_game(self):
side = int(input('choose your side\n0: O, 1: X'))
player_1 = 1 if side == 0 else -1
# player_2 = -player_1
print('Start\n', self.G)
t = time.time()
player = 1
for i in range(100):
if player == player_1:
y, x = self.T.search(self.G.get_state() * player_1)
else:
y = int(input('y:'))
if y < 0:
break
x = int(input('x:'))
if self.G.input(y, x, player):
break
player = -player
t = time.time() - t
print('Time:', t)
# save cache
self.S.save(self.T.EF.Hash)
print('End')
def __init__(self):
"""Constructor for package class
Methods:
- search_song: to search for songs
- save_song: to save song infomation to file
- search_artist: to search for artist
- save artist: to save artist information to file
- get_annotations: for getting song annotations
- get_article_links: For getting links and titles of articles currently on the genius home page
- get_article: For getting an articles currently on the genius home page
- get_chart: For getting chart of top trending songs
"""
self.search_bot = Search_Genius()
self.save_bot = Save()
self.interact_bot = Interact()
self.web_bot = Webpage()
def list_item(self, data, filename, ident):
if not data:
# self.list_installed()
return
save = Save(savedata=data,
ident=ident,
filename=filename,
filesystem=self.filesystem)
return 0, save
class Eve:
def __init__(self, n, m, depth, save_permission):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.G = Game(n, m)
self.T1 = Tree(n, m, depth)
self.T2 = Tree(n, m, depth)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T1.EF.Hash = out
self.T2.EF.Hash = out
def start_game(self):
# first move: X
print('Start\n', self.G)
t = time.time()
for i in range(20):
if i % 2 == 0:
player = 1
next_move = self.T1.search(self.G.get_state())
else:
player = -1
next_move = self.T1.search(-self.G.get_state())
y, x = next_move
if self.G.input(y, x, player):
break
t = time.time() - t
print('Time:', t)
# save cache
self.S.save(self.T1.EF.Hash, self.T2.EF.Hash)
print('End')
def __init__(self, n, m, depth, save_permission, user_id, team_id,
game_id):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.SLEEP_TIME = 5
self.G = Game(n, m)
self.T = Tree(n, m, depth)
self.API = Api(user_id, team_id)
self.API.set_game_id(game_id)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T.EF.Hash = out
def __init__(self, parent=None):
super(MyWindow, self).__init__(parent)
self.setupUi(self)
# 窗体图标
self.setWindowIcon(QIcon("ip_cheat.ico"))
self.scan = Scan()
self.config = Config()
self.save = Save()
self.attack = Attack()
self.cheat = None
self.scan.host_scan_status.connect(self.add_host_result)
self.scan.port_scan_status.connect(self.add_port_result)
for val in self.config.ipv4_adp.keys():
self.send_card.addItem(val)
_translate = QtCore.QCoreApplication.translate
self.need_scan_ip_T.setPlainText(_translate("MainWindow", "192.168.1.142"))
self.save_file_path_T.setPlainText(_translate("MainWindow", "D:/PycharmProjects/IP欺骗"))
self.cheat_port_T.setPlainText(_translate("MainWidow", "80"))
self.send_card.setCurrentText(_translate("MainWidow", "192.168.1.1"))
def start(self):
loaded = False
if saved_game := Save(game=self._game).load():
choice = input("The program detected an unfinished game from last time, do you want to continue? y/N: ")
while choice not in ("y", "N"):
if choice == "exit":
print("Cannot exit right now.")
choice = input("Wrong choice, try again: ")
if choice == "y":
self._game = saved_game
loaded = True
def __init__(self):
"""Constructor for Script class
Methods:
- start: to start the main script
- get_articles: to retrieve articles from the genius web page
- print_articles: for printing articles to screen
- get_Searching: to initiate the searching module
- get_chart: to retrieve a chart of the top 10 songs
- space_cre: for creating gaps in tables(charts)
"""
banner = Figlet(font='standard')
print(banner.renderText("BLyrics"))
# i have to make objects for each class
# the script isn't working without ding it like this
self.search_bot = Search_Genius()
self.interact_bot = Interact()
self.save_bot = Save()
self.web_bot = Webpage()
# and add positional arguments
print()
print("Welcome To BLyrics")
print()
print(
'If you are new to BLyrics please check the help guide by typing help'
)
print('Ignore to continue')
print()
comd = input(": ").lower()
if comd == 'help':
print('Welcome to BLyrics')
print("To go back, enter 'back'(lower case)")
print("To return to start page, enter 'menu'(lower case)")
print("To exit, enter 'ctrl+Z'")
print('Follow the prompt and you should be fine :)')
time.sleep(3)
for i in range(2):
print()
self.start()
def add_new_id(self):
cap.release()
cv2.destroyAllWindows()
self.run.stop()
self.widget = QtWidgets.QWidget()
save = Save()
self.save.setupUi(self.widget)
self.widget.show()
self.widget.addWidget(self.widget)
self.widget.setCurrentIndex(self.widget.currentIndex() + 1)
def doSave():
req = request.get_json()
wiki = req['wiki']
domain = "{}.wikipedia.org".format(wiki)
userStatus, session, respFromGettingUserInfo = getUserInfo(domain)
if not userStatus:
return jsonify(respFromGettingUserInfo)
#
userName = respFromGettingUserInfo['username'] if 'username' in respFromGettingUserInfo else respFromGettingUserInfo['message']
job = req['job']
article = req['article']
result = req['result']
wikitext = req['wikitext']
status = req['status']
handlingSave = Save(session)
respFromSave = handlingSave.saveArticle(job,article,result,wikitext,status,userName)
return jsonify(respFromSave)
def saveFile(self):
if self.filename is '':
self.filename = QFileDialog.getSaveFileName(self.piirtoalusta)[0]
if self.filename is not '':
items = self.piirtoalusta.scene.items()
if '.txt' not in self.filename:
self.filename = "".join((self.filename, '.txt'))
textfile = QSaveFile(self.filename)
textfile.open(QIODevice.WriteOnly | QIODevice.Text)
output = QByteArray()
items = self.piirtoalusta.scene.items()
save = Save(items)
output.append(save.content)
textfile.write(output)
textfile.commit()
return save.content
def drawNext(self):
#return the next card
self.card_index = self.i
self.last_card = self.current_card
self.current_card = self.deck[self.i]
# print("Card index: ", self.card_index)
# print("Maybe card index: ", self.i)
# print("Current card: ", self.current_card)
self.i += 1
if (self.i > 44):
self.shuffle()
self.i = 0
from save import Save
self.main.save = Save(self.main)
self.main.save.save()
return self.current_card
def back_button(self):
game = Save(game=self.gui.game).load()
if not game:
self.controller.frames["MainMenu"].button2.configure(
state="disabled")
else:
self.controller.frames["MainMenu"].button2.configure(
state="normal",
command=lambda: self.controller.frames["MainMenu"
].continue_game(game))
for i in range(self.gui.game.board_player.height):
for j in range(self.gui.game.board_player.width):
self.computer[i][j].photo.thing.place_forget()
self.computer[i][j].photo.thing.destroy()
self.player[i][j].photo.thing.place_forget()
self.player[i][j].photo.thing.destroy()
self.place_forget()
self.destroy()
self.controller.show_frame("MainMenu")
def setUpBoard(self):
finished = True
if self.main.numPlayers == "one" and self.main.pc1difficulty == '':
finished = False
if self.main.numPlayers == "two" and (self.main.pc1difficulty == '' or
self.main.pc2difficulty == ''):
finished = False
if self.main.numPlayers == "three" and (
self.main.pc1difficulty == '' or self.main.pc2difficulty == ''
or self.main.pc3difficulty == ''):
finished = False
if finished:
self.main.activeObj = set()
self.main.board = Board(self.main)
self.main.game = Game(self.main)
self.main.deck = Deck(self.main)
self.main.deck.start_deck()
self.main.save = Save(self.main)
#commented out because this was casuing an error
self.main.save.save()
self.main.gameStarted = True
def option_critic_run(defaults):
collector = Collector(**defaults)
env = Game(**defaults)
buffer = ReplayBuffer(**defaults)
batch = env.batch
num_options = len(env.layers.layers) - 3
option_critic = OptionCriticConv(in_features=env.board.shape[1],
num_actions=4,
num_options=num_options,
width=env.board.shape[2],
height=env.board.shape[3],
temperature=0.005,
eps_start=2000000,
eps_min=0.2,
eps_decay=2000000,
eps_test=0.05,
device=device)
# Create a prime network for more stable Q values
option_critic_prime = deepcopy(option_critic)
optim = torch.optim.RMSprop(option_critic.parameters(), lr=0.0005)
with Save(env, collector, **defaults) as save:
states = option_critic.get_state(env.board)
greedy_options = [
e.item() for e in list(option_critic.greedy_option(states))
]
current_options = [0 for _ in range(batch)]
option_terminations = [True for _ in range(batch)]
dones = [False for _ in range(batch)]
actions, logps, entropys = [None for _ in range(batch)
], [None for _ in range(batch)
], [None for _ in range(batch)]
for frame in loop(env, collector, save):
epsilon = option_critic.epsilon
#print(epsilon)
states = option_critic.get_state(env.board)
#print(states.shape)
for i, done in enumerate(dones):
if done:
greedy_options[i] = option_critic.greedy_option(
states[i]).item()
current_options[i] = 0
option_terminations[i] = True
actions[i] = None
logps[i] = None
entropys[i] = None
#print(greedy_options)
for i, (option_termination, current_option, state,
greedy_option) in enumerate(
zip(option_terminations, current_options, states,
greedy_options)):
if option_termination:
current_options[i] = np.random.choice(
num_options
) if np.random.rand() < epsilon else greedy_option
actions[i], logps[i], entropys[i] = option_critic.get_action(
state, current_option)
# print(logps[0], entropys[0])
old_obses = env.board
next_obses, rewards, dones, _ = env.step(torch.tensor(actions))
collector.collect([rewards], [dones])
buffer.save_option_critic(old_obses, current_options, rewards,
next_obses, dones)
states = option_critic.get_state(next_obses)
loss = 0
for i, (next_obs, reward, done, state, current_option, old_obs,
logp, entropy) in enumerate(
zip(next_obses, rewards, dones, states,
current_options, old_obses, logps, entropys)):
option_terminations[i], greedy_options[
i] = option_critic.predict_option_termination(
state.unsqueeze(0), current_option)
loss += actor_loss_fn(old_obs, current_option, logp, entropy,
reward, done, next_obs, option_critic,
option_critic_prime)
if frame % update_frequency == 0:
data_batch = buffer.sample_option_critic()
loss += critic_loss_fn(option_critic, option_critic_prime,
data_batch)
optim.zero_grad()
loss.backward()
optim.step()
if frame % freeze_interval == 0:
option_critic_prime = deepcopy(option_critic)
def __init__(self): self.download = Download() self.url_manager = Url_Manager() self.html_parser = Html_Parser() self.save = Save() self.set_color = Set_Color()
def exportCsv(self):
logging.debug('>>')
from save import Save
save = Save(self.data_path, self.record)
save.run()
logging.debug('<<')
def exportCsv(self):
logging.debug('>>')
from save import Save
save = Save(self.data_path, self.record)
save.run()
logging.debug('<<')
def to_db(self, state, winner):
add_game_to_db = Save(self.__hash__())
add_game_to_db.add_players(self.__player_one, self.__player_two)
add_game_to_db.add_board(state.get_states())
add_game_to_db.add_winner(winner)
add_game_to_db.dump_to(Save.DATA_BASE)
def save(self, state):
save_game = Save(self.__hash__())
save_game.add_players(self.__player_one, self.__player_two)
save_game.add_board(state.to_json())
save_game.dump_to(Save.FILE)
class LevelTwo(object):
def __init__(self, m):
"""
:param m: Menu
"""
self.levelName = "levelTwo"
self.gameState = ''
m.game = self
self.menu = m
self.setLight()
self.loadScene()
if self.menu.tempPlayer is None:
self.initCollision()
self.initPlayer()
else:
print 'temp not none'
self.node = self.menu.tempPlayer
self.node.node.setPos(-250, 265, 20)
self.node.game = self
self.node.initMission()
self.node.mission.memoryNum = self.menu.tempPlayer.mission.memoryNum
self.enemy = Enemylevel2(self.node)
# self.node.node.setPos(-800, 0, 20)
# self.node.node.setPos(-370, 2800, 25)
self.node.node.setPos(-700, 0, 25)
self.node.node.setHpr(-90, 0, 0)
base.accept("escape", self.pauseGame)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.mutableMap = {}
self.glowFilter()
self.initMania()
self.finalcard.reparentTo(hidden)
self.initBag()
# self.menu.loadState = True
self.menu.passFrame.show()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
if not self.menu.skipUseless:
self.menu.loadState = True
taskMgr.add(self.waitOne, "waitOne")
else:
self.save = Save(self)
if self.menu.selectedSave == 2:
self.save.loadFile('gameinfo_2.save')
elif self.menu.selectedSave == 3:
self.save.loadFile('gameinfo_3.save')
self.node.changeCamera()
self.menu.loadState = True
self.menu.passFrame.hide()
self.setupskillpattern()
def waitOne(self, task):
if task.time < 1:
self.menu.passFrame['frameColor'] = (0, 0, 0, 1 - task.time)
return task.cont
self.menu.passFrame['frameColor'] = (0, 0, 0, 0)
self.menu.passFrame.hide()
self.beginPlot()
return task.done
def beginPlot(self):
self.menu.ocanioDialog.show()
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.node.endTask()
self.nextPlot()
def nextPlot(self):
self.menu.ocanioButton['text'] = '刚一踏出房间，房间的门就被重重的锁上了。无论我怎么叫喊，\n' \
'里面都没有回应。我尽可能不去想最糟糕的情况，大概kura不会有什么问题的吧。'
self.menu.ocanioButton['command'] = self.node.mission.hideOcanio
self.menu.ocanioButton['extraArgs'] = []
def initBag(self):
self.bagState = True
self.bagText = ""
if self.menu.tempPlayer is not None:
self.node.bag = self.menu.tempPlayer.bag
else:
self.node.bag = Bag(self.node)
base.accept("b", self.openBag)
def openBag(self):
# print 'b'
if self.bagState:
self.node.bag.bagframe.show()
self.node.bag.showdisplay.setActive(True)
self.node.bag.textObject.setText(self.bagText)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
base.accept('escape', self.openBag)
else:
self.node.bag.bagframe.hide()
self.node.bag.showdisplay.setActive(False)
self.bagText = self.node.bag.textObject.getText()
self.node.bag.textObject.setText("")
self.node.bag.textObject.setWordwrap(0)
self.bagState = not self.bagState
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.gameState = ''
self.node.state = ''
self.node.initTask()
base.accept('escape', self.pauseGame)
def initCollision(self):
""" create the collision system """
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
base.cTrav.setRespectPrevTransform(True)
def loadScene(self):
""" load the self.sceneModel
must have
<Group> *something* {
<Collide> { Polyset keep descend }
in the egg file
"""
self.goodmanager = GoodsManager()
# AddGoods(self,Node,CollisionName,Name,Interactive)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Scene2_light.egg'),
["light"], "light", False)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Scene2_Ver7.0_wall.egg'),
["Wall", "floor"], "wall", False)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Elevator/dianti.egg'),
["dianti"], "dianti_box", True)
self.goodmanager.AddGoods(loader.loadModel('res/models/Scene2/Scene2Cat/Elevator/broken_dianti.egg'),
["broken_dianti"], "broken_dianti_box", True)
self.goodmanager.GoodsIta['broken_dianti_box'].Node.hide()
'''
corridor
'''
prefix = 'res/models/Scene2/Scene2Cat/Corridor/Scene2_Ver5.0_'
self.loadIn(prefix + 'clock_2.egg', "clock_box", True)
# self.loadIn(prefix + 'Outdoor.egg', "outdoor_box", True)
self.loadIn(prefix + 'ElectricBox_2.egg', "ElectricBox", True)
self.loadIn(prefix + 'entrance.egg', "entrance_box", True)
self.loadIn(prefix + 'picture1.egg', "painting_1", True)
self.loadIn(prefix + 'picture2.egg', "painting_2", True)
self.loadIn(prefix + 'picture3.egg', "painting_3", True)
self.loadIn(prefix + 'picture4.egg', "painting_4", True)
self.loadIn(prefix + 'picture5.egg', "painting_5", True)
self.loadIn(prefix + 'picture6.egg', "painting_6", True)
self.loadIn(prefix + 'picture7.egg', "painting_7", True)
self.loadIn(prefix + 'picture8.egg', "painting_8", True)
self.loadIn(prefix + 'picture9.egg', "painting_9", True)
self.loadIn(prefix + 'picture8_cut.egg', "painting_cut", True)
self.goodmanager.GoodsIta["painting_cut"].Node.hide()
self.goodmanager.GoodsIta["outdoor_box"] = Door(Vec3(374.1351, 1973.22, 105.000), "outdoor_box",
prefix + 'Outdoor.egg', 90, Door.Out)
'''
hall
'''
prefix = 'res/models/Scene2/Scene2Cat/Hall/Scene2_Ver5.0_'
self.loadIn(prefix + 'food.egg', 'food_box', True)
self.loadIn(prefix + 'cake.egg', 'cake_box', True)
self.loadIn(prefix + 'diary.egg', 'diary_box', True)
self.loadIn(prefix + 'safe_2.egg', 'safe_box', True)
self.loadIn(prefix + 'carrot.egg', 'carrot_box', True)
self.loadIn(prefix + 'window.egg', 'window_box', True)
self.loadIn(prefix + 'window_broken.egg', 'window_broken_box', True)
self.goodmanager.GoodsIta['window_broken_box'].Node.hide()
self.loadIn(prefix + 'biaoyu.egg', 'biaoyu_box', True)
# self.loadIn(prefix + 'Backdoor.egg', 'backdoor', True)
# self.loadIn(prefix + 'Frontdoor.egg', 'frontdoor', True)
self.loadIn(prefix + 'hammer_2.egg', 'hammer_box', True)
self.loadIn(prefix + 'zhalan_2.egg', 'rabbit_cage', True)
self.loadIn(prefix + 'vaccine.egg', 'hallvaccine_box', True)
self.loadIn(prefix + 'refrigerator_2.egg', 'fridge_box', True)
self.loadIn(prefix + 'rabbit.egg', 'rabbit_box', False)
self.loadIn(prefix + 'yuanzhuo.egg', 'yuanzhuo_box', False)
self.loadIn(prefix + 'changzhuo_2.egg', 'changzhuo_box', False)
self.goodmanager.GoodsIta["Frontdoor"] = Door(Vec3(342.9760, 357.22, 105.000), "Frontdoor",
prefix + 'Frontdoor.egg', 90, Door.Out)
self.goodmanager.GoodsIta["Backdoor"] = Door(Vec3(342.9760, 1571.22, 105.000), "Backdoor",
prefix + 'Backdoor.egg', 90, Door.Out)
'''
Outroom
'''
prefix = 'res/models/Scene2/Scene2Cat/Outroom/Scene2_Ver5.0_'
self.loadIn(prefix + 'vase_2.egg', 'vase_box', True)
self.loadIn(prefix + 'knife.egg', 'knife_box', True)
self.loadIn(prefix + 'jiazi_2.egg', 'jiazi_box', False)
self.loadIn(prefix + 'rongqi.egg', 'rongqi_box', False)
self.loadIn(prefix + 'vaccine.egg', 'vaccine_box', True)
self.loadIn(prefix + 'lavabo_2.egg', 'lavabo_box', True)
self.loadIn(prefix + 'mirror.egg', 'mirror_box', True)
self.loadIn(prefix + 'furnace_2.egg', 'furnace_box', True)
self.loadIn(prefix + 'bookshelf.egg', 'bookshelf_box', True)
self.loadIn(prefix + 'xiaozhuozi_2.egg', 'xiaozhuozi_box', False)
self.goodmanager.staticGoods["infireish"] = GoodsParticle("fireish", (-370, 3183, 25), 16, render,31)
self.goodmanager.staticGoods["insteam"] = GoodsParticle("steam", (-370, 3183, 50), 5, render,30)
self.goodmanager.GoodsIta['Scene2_book-beijuji'] = Book(prefix+'beijuji.egg','beijuji',(-350, 3183, 50))
self.goodmanager.GoodsIta['Scene2_book-beijuji'].Node.setHpr(30, 30, 30)
for i in range(8):
name = "outflowers" + str(i+1)
self.goodmanager.AddGoods(loader.loadModel(prefix + name + '.egg'),
[name], name, False)
self.goodmanager.staticGoods[name].Node.setTwoSided(True)
self.goodmanager.staticGoods['outflowers7'].Node.hide()
self.goodmanager.staticGoods['outflowers8'].Node.hide()
self.mirrorShader = loader.loadShader("shaders/mirrorShader.sha")
self.goodmanager.GoodsIta['mirror_box'].Node.setShader(self.mirrorShader)
# self.goodmanager.GoodsIta['mirror_box'].Node.setTwoSided(True)
self.mirror(self.goodmanager.GoodsIta['mirror_box'].Node)
'''
Inroom
'''
prefix = 'res/models/Scene2/Scene2Cat/Inroom/Scene2_Ver5.0_'
self.loadIn(prefix + 'invase.egg', 'invase_box', True)
self.loadIn(prefix + 'inknife.egg', 'inknife_box', True)
self.loadIn(prefix + 'injiazi.egg', 'injiazi_box', False)
self.loadIn(prefix + 'inlavabo.egg', 'inlavabo_box', True)
self.loadIn(prefix + 'inrongqi.egg', 'inrongqi_box', False)
self.loadIn(prefix + 'infurnace.egg', 'infurnace_box', True)
self.loadIn(prefix + 'inbookshelf.egg', 'inbookshelf_box', True)
self.loadIn(prefix + 'inxiaozhuozi.egg', 'inxiaozhuozi_box', False)
self.goodmanager.staticGoods["fireish"] = GoodsParticle("fireish", (-370, 2870, 25), 16, render, 31)
self.goodmanager.staticGoods["steam"] = GoodsParticle("steam", (-370, 2870, 50), 5, render, 30)
self.goodmanager.GoodsIta['Scene2_book-xijuji'] = Book(prefix + 'inxijuji.egg', 'inxijuji', (-350, 2870, 50))
self.goodmanager.GoodsIta['Scene2_book-xijuji'].Node.setHpr(30, 30, 30)
for i in range(8):
name = "inflowers" + str(i+1)
self.goodmanager.AddGoods(loader.loadModel(prefix + name + '.egg'),
[name], name, False)
self.goodmanager.staticGoods[name].Node.hide()
self.goodmanager.staticGoods[name].Node.setTwoSided(True)
self.goodmanager.staticGoods['inflowers1'].Node.show()
self.h2so4_1 = GoodsParticle("H2SO4", (-380, 2270, 136), 6, render, 32)
self.h2so4_2 = GoodsParticle("smo", (-380, 2270, 110), 5, render, 33)
self.h2so4_3 = GoodsParticle("surface-1", (-365, 2270, 100), 10, render, 34)
self.h2so4_3.particle.setScale(10, 20, 10)
self.h2so4_4 = GoodsParticle("H2SO4", (-380, 3895.5, 136), 6, render, 32)
self.h2so4_5 = GoodsParticle("smo", (-380, 3890, 110), 5, render, 33)
self.h2so4_6 = GoodsParticle("surface-1", (-363, 3890, 100), 10, render, 34)
self.h2so4_6.particle.setScale(10, 20, 10)
def loadIn(self, path, name, b):
self.goodmanager.AddGoods(loader.loadModel(path), [name], name, b)
def itemCollision(self, model, name, radius):
nodePath = NodePath(name)
node = CollisionNode(name)
node.addSolid(CollisionSphere(20, 0, radius, radius))
solid = model.attachNewNode(node)
nodePath.reparentTo(model)
solid.show()
base.cTrav.addCollider(solid, base.pusher)
base.pusher.addCollider(solid, nodePath, base.drive.node())
def initPlayer(self):
""" loads the player and creates all the controls for him"""
self.node = Player(self.goodmanager, self.menu, self)
# self.enemy = Enemy(self.node)
self.enemy = Enemylevel2(self.node)
# self.goodmanager.GoodsIta["enemy"] = Enemy(self.node)
# self.goodmanager.GoodsIta["enemy"].state = 1
def pauseGame(self):
props = WindowProperties()
props.setCursorHidden(False)
base.win.requestProperties(props)
self.menu.selectDialog.hide()
self.gameState = 'pause'
self.node.state = 'pause'
self.node.endTask()
self.node.erosionFrame.hide()
self.node.currentItemFrame.hide()
base.accept('escape', self.escapeEvent)
base.accept('b', self.menu.nothing)
self.menu.pauseFrame.show()
def escapeEvent(self):
self.menu.pauseFrame.hide()
self.node.state = ''
self.node.initTask()
self.node.erosionFrame.show()
self.node.currentItemFrame.show()
base.accept('escape', self.pauseGame)
base.accept('b', self.openBag)
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
def mirror(self,tex):
self.mirrorBuffer = base.win.makeTextureBuffer("mirror", 512, 512)
print 'mirrorBuffer',self.mirrorBuffer
self.mirrorBuffer.setSort(-3)
self.mirrorBuffer.setClearColor(LVector4(0, 0, 0, 1))
print base.cam.node().getLens()
self.mirrorCamera = base.makeCamera(self.mirrorBuffer)
self.mirrorCamera.reparentTo(render)
self.mirrorCamera.setPos((424,3080,104. ))
self.mirrorCamera.setH(180)
pl = self.mirrorCamera.node().getLens()
pl.setFov(90)
pl.setNear(100)
self.mirrorCamera.node().setLens(pl)
self.finalcard = self.mirrorBuffer.getTexture()
tex.setTexture(self.finalcard,1)
# self.UnLoadmirror()
def UnLoadmirror(self):
self.mirrorBuffer.getEngine().removeWindow(self.mirrorBuffer)
self.mirrorBuffer = None
self.mirrorCamera = None
def makeFilterBuffer(self, srcbuffer, name, sort, prog):
blurBuffer = base.win.makeTextureBuffer(name, 512, 512)
blurBuffer.setSort(sort)
blurBuffer.setClearColor(LVector4(1, 0, 0, 1))
blurCamera = base.makeCamera2d(blurBuffer)
blurScene = NodePath("new Scene")
blurCamera.node().setScene(blurScene)
shader = loader.loadShader(prog)
card = srcbuffer.getTextureCard()
card.reparentTo(blurScene)
card.setShader(shader)
return blurBuffer
def glowFilter(self):
glowShader = loader.loadShader("shaders/glowShader.sha")
# dlight = DirectionalLight('dlight')
# alight = AmbientLight('alight')
# dlnp = render.attachNewNode(dlight)
# alnp = render.attachNewNode(alight)
# dlight.setColor(LVector4(0.3, 0.3, 0.3, 1))
# alight.setColor(LVector4(0.8, 0.8, 0.8, 1))
# dlnp.setHpr(0, -60, 0)
# render.setLight(dlnp)
# render.setLight(alnp)
# create the glow buffer. This buffer renders like a normal scene,
# except that only the glowing materials should show up nonblack.
glowBuffer = base.win.makeTextureBuffer("Glow scene", 1024, 768)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(LVector4(0, 0, 0, 1))
# We have to attach a camera to the glow buffer. The glow camera
# must have the same frustum as the main camera. As long as the aspect
# ratios match, the rest will take care of itself.
self.glowCamera = base.makeCamera(
glowBuffer, lens=base.cam.node().getLens())
# Tell the glow camera to use the glow shader
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(glowShader)
self.glowCamera.node().setInitialState(tempnode.getState())
self.glowCamera.node().setCameraMask(BitMask32.bit(0))
# set up the pipeline: from glow scene to blur x to blur y to main
# window.
blurXBuffer = self.makeFilterBuffer(
glowBuffer, "Blur X", -2, "shaders/XBlurShader.sha")
blurYBuffer = self.makeFilterBuffer(
blurXBuffer, "Blur Y", -1, "shaders/YBlurShader.sha")
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
Attrib = ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.O_incoming_alpha,
ColorBlendAttrib.O_incoming_alpha)
self.finalcard.setAttrib(Attrib)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
base.bufferViewer.setCardSize(0.652, 0)
base.accept("tab", self.toggleGlow)
self.glowOn = False
def limitGlow(self, task):
if task.time < 5:
return task.cont
else:
self.glowOn = False
self.finalcard.reparentTo(hidden)
# self.goodmanager.GoodsIta["box"].CloseHighLight()
return task.done
def toggleGlow(self):
self.showskillpattern("eyepattern")
if self.glowOn:
return
self.glowOn = True
taskMgr.add(self.limitGlow, "limitGlow")
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
self.finalcard.reparentTo(render2d)
# self.goodmanager.GoodsIta["box"].OpenHighLight()
def initMania(self):
base.accept("space", self.mania)
self.maniaState = False
def mania(self):
self.showskillpattern("maniapattern")
if not self.maniaState:
self.node.speed *= 1.4
self.maniaState = True
if self.node.EROSION + 10 > 100:
self.node.EROSION = 100
else:
self.node.EROSION += 10
taskMgr.remove("fadeSpeed")
taskMgr.add(self.fadeSpeed, "fadeSpeed")
def fadeSpeed(self, task):
if task.time < 10:
return task.cont
else:
self.node.speed /= 1.4
self.maniaState = False
return task.done
def setupskillpattern(self):
self.eyepattern = OnscreenImage(image="res/skill_icon/eye-white.png", pos=(-1.2, 1, -0.8))
self.eyepattern.setTransparency(TransparencyAttrib.MAlpha)
self.eyepattern.setScale(0.1)
self.eyepattern.setSa(0.8)
self.eyepattern.hide()
self.maniapattern = OnscreenImage(image="res/skill_icon/mania-white.png", pos=(-1.2 + 0.3, 1, -0.8))
self.maniapattern.setTransparency(TransparencyAttrib.MAlpha)
self.maniapattern.setScale(0.1)
self.maniapattern.setSa(0.8)
self.maniapattern.hide()
self.screen_patternArray = {}
self.screen_patternArray["eyepattern"] = [self.eyepattern, False, 5.0, 5.0]
self.screen_patternArray["maniapattern"] = [self.maniapattern, False, 10.0, 10.]
self.patterntask = False
self.patterntaskpretime = 0
# self.mouseIconNormal.setSa(0.5)
def showskillpattern(self, patternname):
self.screen_patternArray[patternname][2] = self.screen_patternArray[patternname][3]
self.screen_patternArray[patternname][1] = True
self.screen_patternArray[patternname][0].show()
if self.patterntask == False:
taskMgr.add(self.showskillpatterntask, "showskillpatterntask")
self.patterntask = True
def showskillpatterntask(self, task):
num = 0
for key in self.screen_patternArray:
if self.screen_patternArray[key][1] == True:
self.screen_patternArray[key][2] -= globalClock.getDt()
if self.screen_patternArray[key][2] < 5.:
if sin(self.screen_patternArray[key][2] * pi * 5) > 0:
self.screen_patternArray[key][0].setSa(0)
else:
self.screen_patternArray[key][0].setSa(0.8)
self.screen_patternArray[key][0].setPos(-1.2 + num * 0.3, 1, -0.8)
if self.screen_patternArray[key][2] < 0:
self.screen_patternArray[key][1] = False
self.screen_patternArray[key][0].hide()
self.screen_patternArray[key][0].setSa(0.8)
num += 1
if num > 0:
return task.cont
self.patterntask = False
return
def setLight(self):
render.setLightOff()
alight=AmbientLight('alight')
alnp=render.attachNewNode(alight)
alight.setColor(VBase4(0.3,0.3,0.3,1))
render.setLight(alnp)
# myFog = Fog("Fog Name")
# myFog.setColor(0.2,0.5, 0.1)
# myFog.setExpDensity(0.5)
# render.setFog(myFog)
self.lightpivot1 = render.attachNewNode("lightpivot1")
self.lightpivot1.setPos(-124, 947, 50)
self.plight1=PointLight('plight1')
self.plight1.setColor(VBase4(1, 0.5, 0, 1))
self.temp=LVector3(0.6, 0.08, 0)
self.plight1.setAttenuation(self.temp)
plnp1=self.lightpivot1.attachNewNode(self.plight1)
plnp1.setPos(0,0,50)
render.setLight(plnp1)
self.lightpivot2 = render.attachNewNode("lightpivot2")
self.lightpivot2.setPos(0, 0, 50)
self.plight2 = PointLight('plight2')
self.plight2.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.08, 0)
self.plight2.setAttenuation(self.temp)
plnp2 = self.lightpivot2.attachNewNode(self.plight2)
plnp2.setPos(-200, 0, 50)
render.setLight(plnp2)
self.lightpivot3 = render.attachNewNode("lightpivot3")
self.lightpivot3.setPos(52, 2491, 50)
self.plight3 = PointLight('plight3')
self.plight3.setColor(VBase4(1, 0.5, 0, 1))
self.temp = LVector3(0.6, 0.08, 0)
self.plight3.setAttenuation(self.temp)
plnp3 = self.lightpivot3.attachNewNode(self.plight3)
plnp3.setPos(-200, 0, 50)
render.setLight(plnp3)
slight = Spotlight('slight')
slight.setColor(VBase4(0.1, 0.5, 0.1, 1))
#slight.setAttenuation(LVector3(0.5,0.08,0))
lens = PerspectiveLens()
lens.setFov(10)
slight.setLens(lens)
slnp = render.attachNewNode(slight)
slnp.setPos(-811, 3, 0)
slnp.lookAt(415,10,0)
# slnp.setPos(0,0,0)
# slnp.lookAt(0,0,50)
render.setLight(slnp)
def to_db(self, state, winner):
add_game_to_db = Save(self.__hash__())
add_game_to_db.add_players(self.__player_one, self.__player_two)
add_game_to_db.add_board(state.get_states())
add_game_to_db.add_winner(winner)
add_game_to_db.dump_to(Save.DATA_BASE)
def save(self, state):
save_game = Save(self.__hash__())
save_game.add_players(self.__player_one, self.__player_two)
save_game.add_board(state.to_json())
save_game.dump_to(Save.FILE)
