def __init__(self): self._ip = "47.88.23.214" self._port = 8888 self._timeout = 10 self._net = Net(self._ip, self._port, self._timeout) basemodule = BaseModule(0x00010000) MsgHandler().registerModule(basemodule)
class Server: def __init__(self, config): GM().setServer(self) self._host = config["host"] self._port = config["port"] self._timeout = config["timeout"] # 创建消息分发器 self._msgHandler = MsgHandler() # 向消息分发器注册消息处理模块 baseModule = BaseModule(0x00010000) self._msgHandler.registerModule(baseModule) # 初始化网络并监听 self._net = Net(self._host, self._port, self._timeout, self._msgHandler) def run(self): self._net.run() def stop(self): self._net.stop() def getNet(self): return self._net
def __init__(self): self.model = Net() self.model.load_state_dict(torch.load('FACENET.pth')) self.model.eval() cascPath = "./haarcascade_frontalface_alt.xml" self.faceCascade = cv2.CascadeClassifier(cascPath)
class Predictor: def __init__(self): self.model = Net() self.model.load_state_dict(torch.load('FACENET.pth')) self.model.eval() cascPath = "./haarcascade_frontalface_alt.xml" self.faceCascade = cv2.CascadeClassifier(cascPath) def extractFace(self): self.patches = [] self.coordinates = [] faces = self.faceCascade.detectMultiScale( self.gray, scaleFactor=1.1, minNeighbors=5, minSize=(50, 50), #flags=cv2.cv.CV_HAAR_SCALE_IMAGE flags=cv2.CASCADE_SCALE_IMAGE) print("Found %d faces" % (len(faces))) for (x, y, w, h) in faces: patch = self.gray[y:y + h, x:x + w] / 255. patch = cv2.resize(patch, (32, 32)) self.patches.append(np.array(patch.astype(np.float32))) self.coordinates.append([x, x + w, y, y + h]) def setImageFname(self, imagefilename): self.img = cv2.imread(imagefilename) self.gray = cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY) def setImage(self, img): self.img = img if self.img.shape[2] is not None: self.gray = cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY) else: self.gray = self.img def pred(self): if len(self.patches) > 0: # get random image patch patch_data = torch.from_numpy(np.array([self.patches])) data = Variable(patch_data, volatile=True) ret = self.model(data) outputs = ret[0] for idx, output in enumerate(outputs): pred = np.argmax(output.cpu().data.numpy()) #x = self.coordinates[idx][0] #y = self.coordinates[idx][2] #x2 = self.coordinates[idx][1] #y2 = self.coordinates[idx][3] #cv2.rectangle(self.img, (x,y),(x2,y2), (255,0,255),2) #print(mylabels[pred]) #cv2.imshow("face",self.img) #cv2.waitKey(0) return ret
def add_game_balance(self, value): """ Fills the current client's game balance. """ if value > 0: cmd = Commands.AddGameBalanceCommand(self.__client, value) Net.send(cmd) if cmd.rejected: raise RuntimeError("Cannot change game balance.")
def __init__(self): self.pnet = Net.PNet() self.pnet.load_state_dict(torch.load("pnet.pt")) self.pnet.eval() self.rnet = Net.RNet() # self.rnet.load_state_dict(torch.load("rnet.pt")) self.onet = Net.ONet()
def buy_unlocks(self): """ Attempts to buy unlocks for chapter. :return: True in case of success, False otherwise. :rtype: bool """ cmd = Commands.BuyChapterUnlocksCommand(self.__client) Net.send(cmd) return not cmd.rejected
def unlock(self): """ Attempts to unlock chapter. :return: True in case of success, False otherwise. :rtype: bool """ cmd = Commands.UnlockChapterCommand(self.__client) Net.send(cmd) return not cmd.rejected
def upload(self): if str(self.__client.network) != "device": """ Uploads storage data. """ if self.__get_parent() is not None: self.__get_parent().upload() else: if not self.__is_locked(): self.__lock() Net.send(Commands.UpdateStorage(self.__client.storage_session, self.__client.session, self)) self.__unlock()
def createServer(self): Port = Net.GetPort(14250) TMP = os.environ["TMP"] if not os.path.exists(TMP + "/Port"): os.makedirs(TMP + "/Port") try: fs = open(TMP + "/Port/Port.log", "w") fs.write(str(Port)) fs.close() except: pass print Port self.Server = Net.Server("127.0.0.1", Port) self.Server.signal.connect(self.ServerData)
def pickle_practicew(): a = hello b = hello a() n = Net.Net([10], 10, [a, b]) pickle.dump(n, open("save.p", "wb"))
def generate_new(self): raw_str = " \nnothing\n " self.net_success = True try: self.log.put("running net") start_time = time.time() raw_str = Net.run(1000).decode("utf-8") #runs the net for 1000 characters delta_time = time.time() - start_time self.log.put("finished running net. took " + str(delta_time) + " seconds, that's " + str(1000.0 / delta_time) + " characters per second") self.net_success = True except: raw_str = " \nif this message shows up, something went wrong\n " self.net_success = False self.log.put("couldn't run net") new_joke_arr = [] raw_str = raw_str.replace("|", " ") raw_str = raw_str.replace("\\","") new_joke_arr = raw_str.split("\n") if(len(new_joke_arr) > 2): for new_joke in new_joke_arr[1:-1]: new_joke_pc = self.make_PC(new_joke) h = hash(new_joke_pc) if not h in self.db["old"]: self.db["new"].append(new_joke_pc) else: self.db["new"] = ["Couldn't get any jokes from my stupid neural network, it did produce something but it's crap"] self.net_success = False self.log.put("generated " + str(len(self.db["new"])) + " new jokes")
def delete(self): """ Deletes message from inbox. """ return not Net.send( Commands.DeleteMessagesCommand(self.__client, [self.__id])).rejected
def testGame(envName, verbose=True): env = Definitions.makeSeededEnvironment(envName) net = Net.Net(env.observation_space, env.action_space) net = net.to(Definitions.device) policy = PolicyLearner.PolicyLearner(net) dataHandler = DataHandler.DataHandler(policy, env) sumReward = 0. maxReward = -1e9 nIters = 20 for i in range(nIters): dataHandler.render(episodes=3) confidenceMul = i policy.setConfidenceMul(confidenceMul) for j in range(10): reward = dataHandler.generate(episodes=10) dataHandler.reset(keepSize=40000) dataHandler.train(batchSize=8, useFraction=0.1) if verbose: print(envName, " iteration:", str(i + 1) + "/" + str(nIters), " reward:", reward, " trained on:", len(dataHandler.inputs), " confidence multipiler:", confidenceMul) sumReward += reward maxReward = max(maxReward, reward) Definitions.saveModel(net, envName, i + 1, reward) avgReward = sumReward / nIters if verbose: print("%s Avg: %.2f Max: %.2f" % (envName, avgReward, maxReward)) print() env.close() return avgReward, maxReward
def save_model(): sess_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess_config.gpu_options.allow_growth = True sess_config.gpu_options.per_process_gpu_memory_fraction = 0.9 sess = tf.InteractiveSession(config=sess_config) x = tf.placeholder(dtype=tf.float32, shape=[1, None, None, 3], name='input') net = Net.Net(x, keep_prop=1.0, trainable=False, training=False, reuse=False, train_mode=FLAGS.train_mode) tools.print_all_variables(train_only=False) output = tf.cast(net.outputs*255, tf.uint8, name='output') sess.run(tf.global_variables_initializer()) saver = tf.train.Saver(max_to_keep = 3, write_version = 2) if tools.check_file_exist(FLAGS.out_model_dir+'/model.npz'): tools.load_and_assign_npz_dict(name=FLAGS.out_model_dir+'/model.npz', sess=sess) else: saver.restore(sess, FLAGS.out_model_dir+'/model.ckpt') print('load model from model dir!!!!') save_path = saver.save(sess, FLAGS.save_model_dir+'/model.ckpt') print('save_path', save_path) output_graph_def = tf.graph_util.convert_variables_to_constants(sess, sess.graph_def, output_node_names=['output']) with tf.gfile.FastGFile(FLAGS.save_model_dir+'/mobile-model.pb', mode='wb') as f: f.write(output_graph_def.SerializeToString()) tools.save_npz_dict(save_list=tf.global_variables(), name=FLAGS.save_model_dir+'/model.npz', sess=sess) sess.close()
def get_media_url(web_url): headers = {'User-Agent': FF_USER_AGENT} net = Net.Net() response = net.http_GET(web_url, headers=headers) html = response.content if re.search('>(File Not Found)<', html): print('File Not Found or removed') cnt = 10 match = re.search('count\s*=\s*(\d+);', html) if match: cnt = int(match.group(1)) cnt += 1 data = get_hidden(html) #print ('data:',data) headers.update({'Referer': web_url}) total = cnt i = 0 #printProgressBar(0, total, 'Progress:', 'Complete', 5) while i < total: progress(i, total, status='Progress:') #printProgressBar(i + 1, total, 'Progress:', 'Complete', 5) time.sleep(0.9) i += 1 html = net.http_POST(response.get_url(), form_data=data, headers=headers).content match = re.compile('''file\s*:\s*["'](?P<url>[^"']+)''', re.DOTALL | re.IGNORECASE).findall(html) return match[0] '''
def run2(): # read data from npz # X_train, y_train = load_train_data() # X_test, y_test = load_test_data() X, y = load_train_data() X_train = X y_train = y indexlist = random.sample(range(53000), 5000) X_test = X[indexlist] y_test = y[indexlist] y_train = np_utils.to_categorical(y_train, 80) y_test = np_utils.to_categorical(y_test, 80) datagen = ImageDataGenerator(featurewise_center=True, featurewise_std_normalization=True, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) test_datagen.fit(X_test) datagen.fit(X_train) model = NetModel.construct_model_inceptionv3() model.fit_generator(datagen.flow(X_train, y_train, batch_size=32), validation_data=(X_test, y_test), steps_per_epoch=len(X_train), epochs=30) model.save("scene_class_resnet101_dataaug_model")
def __init__(self, music, host): super(GameScene, self).__init__() self.background = Surface((WINDOW_WIGTH, WINDOW_HEIGHT)) self.background.fill(Color(BACKGROUND_COLOR)) timer = pygame.time.Clock() self.music = music self.enemy = [] self.net=Net() self.net.subscribe(self.sync) self.host = host mouse.set_pos([200, 300]) self.heroes = [] self.up = self.down = self.left = self.right = False self.entitles_walls = pygame.sprite.Group() self.entitles = pygame.sprite.Group() self.addHero(Player(300, 55, 1)) self.walls = [] #map: self.map = open("maps/testmap.txt", "r") self.x = 0 self.y = 0 self.lenx = 0 self.leny = 0 for self.row in self.map: for self.col in self.row: if self.col == "-": self.wall = wall(self.x, self.y) self.entitles_walls.add(self.wall) self.walls.append(self.wall) if self.col == " ": self.floor = floor1(self.x, self.y) self.entitles_walls.add(self.floor) self.x = self.x + BLOCK_X self.y = self.y + BLOCK_Y self.lenx = self.x / BLOCK_X self.leny += 1 self.x = 0 for i in self.heroes: self.entitles.add(i) total_level_width = self.lenx*WINDOW_WIGTH total_level_height = self.leny*WINDOW_HEIGHT self.camera = Camera(camera_configure, total_level_width, total_level_height) self.enemy = [] if self.host: self.enemy = [Enemy(100, 100, 1), Enemy(200, 200, 2), Enemy(100, 500, 3)] for i in self.enemy: self.entitles.add(i) self.bul = [] self.bul.append(Bullet(0,0)) if self.music == True: pygame.mixer.music.load("music/Game.mp3") pygame.mixer.music.play(-1)
def __init__(self, parent1=None, parent2=None): #the neural net and ball agent of this agent self.net = Net.Net(parent1, parent2) self.ball = Ball.Ball() #random identifier to identify the agent for debug self.identifier = random.randint(0, 50) #true if the user won the game self.agentWon = False
def __init__(self, shape): self.shape = shape self.w = shape[0] self.h = shape[1] W = self.w H = self.h self.state = None #1 for block, 1 for nextblock, 2 for action(loc/rot of block) #8 for each height in board width, outputing 1 Q-value I = len( TetrisState(shape=shape).summary(0) + TetrisAction(0, 0).summary(0)) #print(I) t = [I, I / 2, 1] self.net = Net(t)
def test_run(): print("test") net = Net.Net(input_size, hidden_size, num_classes) net = load_model('../../landmark/model2.pkl',net) #net = load_model('/media/hwejin/SSD_1/DATA/temp_pickles/model2.pkl',net) net.cuda() criterion = nn.CrossEntropyLoss() acc = test(test_loader, net, criterion)
def run_new_species(num): for i in range(num): brains.clear() players.clear() for j in range(v.player_num): brains.append(Net.Net([20], v.inputs, 4)) setup()
def __init__(self, genotype): self.genotype = genotype self.phenotype = self.get_phenotype() from main import layers self.network = Net.Network(layers[:]) self.network = self.update_network() self.time, self.accuracy = self.get_mistake() self.fitness = None
def main(inputs): net = Net.Net() net.addRow() for inp in inputs: net.addNeuron(Neuron.Neuron(bias=float(inp))) net.last() print(net.output()) print(net.toString())
def detect(root, img_file, model_file): net = Net.CTPN() net.load_state_dict(torch.load(model_file)) # net.cuda() print(net) net.eval() text_connector = TextProposalConnector() im = cv2.imread(os.path.join(root, img_file)) # im = Dataset.scale_img(im, None, shortest_side=600) img = copy.deepcopy(im) img = img.transpose(2, 0, 1) img = img[np.newaxis, :, :, :] img = torch.Tensor(img) # img = img.cuda() v, score, side = net(img, val=True) score = score.cpu().detach().numpy()[:, :, :, 1] result = np.where(score > 0.7) for_nms = [] for anchor, height, width in zip(result[0], result[1], result[2]): vc = v[anchor, 0, height, width] vh = v[anchor, 1, height, width] cya = height * 16 + 7.5 ha = anchor_height[anchor] cy = vc * ha + cya h = math.pow(10, vh) * ha pt = other.trans_to_2pt(width, cy, h) for_nms.append( [pt[0], pt[1], pt[2], pt[3], score[anchor, height, width]]) for_nms = np.array(for_nms, dtype=np.float32) nms_result = nms.cpu_nms(for_nms, TEXT_LINE_NMS_THRESH) text_proposals = [] text_proposal_score = [] for i in nms_result: text_proposals.append(for_nms[i, 0:4]) text_proposal_score.append(for_nms[i, 4]) text_proposals = np.array(text_proposals) text_proposal_score = np.array(text_proposal_score) text_proposal_score = other.normalize(text_proposal_score) text_lines = text_connector.get_text_lines(text_proposals, text_proposal_score, im.shape[:2]) keep_index = filter_boxes(text_lines) text_lines = text_lines[keep_index] # nms for text lines if text_lines.shape[0] != 0: keep_inds = nms.cpu_nms(text_lines, TEXT_LINE_NMS_THRESH) text_lines = text_lines[keep_inds] rec = other.draw_boxes(im, text_lines) rec_file = open(os.path.join(img_dir, img_file.split('.')[0] + '.txt'), 'w') rec = rec.tolist() for box in rec: box = [str(pt) for pt in box] rec_file.write(','.join(box)) rec_file.write('\n')
def finish(self, score=None, limit=None, lives=None, boosters=None, rewards=None): """ Attempts to finish level. :return: True in case of success, False otherwise. :rtype: bool """ if score is None: score = self.get_star(Star.FIRST) elif isinstance(score, Star): score = self.get_star(score.value) else: score = int(score) if limit is None: limit = self.get_limit() else: limit = int(limit) if lives is None: lives = 0 else: lives = int(lives) if boosters is not None: for booster in boosters: if not isinstance(booster, Boosters.Booster): booster = self.__client.boosters[booster] if booster.count == 0: booster.force_buy() booster.spend() cmd = None if self.is_bonus: cmd = Commands.FinishBonusLevelCommand(self.__client, self.qualified_id, score, rewards) else: if self.get_limit_type() == Limit.MOVES: cmd = Commands.FinishLevelCommand(self.__client, self.qualified_id, score, used_moves=limit, used_lives=lives, used_boosters=boosters) elif self.get_limit_type() == Limit.TIME: cmd = Commands.FinishLevelCommand(self.__client, self.qualified_id, score, used_time=limit, used_lives=lives, used_boosters=boosters) else: raise RuntimeError("Unknown limit type %s." % limit) Net.send(cmd) return not cmd.rejected
def test_1(): net = Net() train(0, net, trainloader, 0.001) test_train(net, trainloader) test(net, testloader) for i in range(0, 15): train(2, net, trainloader, 0.001) test_train(net, trainloader) test(net, testloader)
def display(): glPushAttrib(GL_ALL_ATTRIB_BITS); glClearColor(1,1,1,1); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); place_camera(); lighting() drawGround() Court.drawTennisCourt() placeScoreCards() positionRacquet() TennisBall.drawBalls(20) Net.drawFullNet() glPopMatrix() cameraDrawing() glFlush(); glutSwapBuffers(); glPopAttrib();
def validation_run(): net = Net.Net(input_size, hidden_size, num_classes) net = load_model('../../landmark/model2.pkl',net) #net = load_model('/media/hwejin/SSD_1/DATA/temp_pickles/model2.pkl',net) net.cuda() criterion = nn.CrossEntropyLoss() print("validation") acc = val(val_loader, net, criterion)
def loadGraph(self, path_workspace): #load il dumping di net try: self.net = nt.Net() self.net.load_net(path_workspace + "/graph.pickle") self.network = self.net.get_network() return self.net except: print("Errore nel caricamento del grafo.") return None
def thread_gray(): tf.reset_default_graph() net = Net.CNN('gray') feature7 = net.output_deepid(patch7, 'checkpoint/patch_7.ckpt') feature8 = net.output_deepid(patch8, 'checkpoint/patch_8.ckpt') feature9 = net.output_deepid(patch9, 'checkpoint/patch_9.ckpt') feature10 = net.output_deepid(patch10, 'checkpoint/patch_10.ckpt') feature11 = net.output_deepid(patch11, 'checkpoint/patch_11.ckpt') feature12 = net.output_deepid(patch12, 'checkpoint/patch_12.ckpt') q.put((feature7, feature8, feature9, feature10, feature11, feature12, 'gray'))
def __init__(self, action_dim): self.count = 0 self.action_dim = action_dim self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.memory = Tools.Memory_Replay(MEMORY_SIZE) self.online = Net.Net(self.action_dim).to(self.device) self.target = Net.Net(self.action_dim).to(self.device) self.optimizer = torch.optim.Adam(self.online.parameters(), LR) self.loss_func = nn.SmoothL1Loss() self.steps_done = 0
def get_user_score(self): """ :return: Client's score. :rtype: int """ rsp = Net.send(Commands.QueryLevels(self.__client.session, [self.qualified_id])) if self.qualified_id in rsp: return rsp[self.qualified_id] else: return 0
def thread_rgb(): tf.reset_default_graph() net = Net.CNN('rgb') feature1 = net.output_deepid(patch1, 'checkpoint/patch_1.ckpt') feature2 = net.output_deepid(patch2, 'checkpoint/patch_2.ckpt') feature3 = net.output_deepid(patch3, 'checkpoint/patch_3.ckpt') feature4 = net.output_deepid(patch4, 'checkpoint/patch_4.ckpt') feature5 = net.output_deepid(patch5, 'checkpoint/patch_5.ckpt') feature6 = net.output_deepid(patch6, 'checkpoint/patch_6.ckpt') q.put((feature1, feature2, feature3, feature4, feature5, feature6, 'rgb'))
def get_messages(self): """ :return: All messages from inbox. :rtype: list """ response = Net.send(Commands.GetMessages(self.__client.session)).response messages = [] for message in response["messages"]: messages.append(Message(self.__client, message)) return messages
def load(self, separately=False): """ Loads chapter's levels. """ if separately: for i in range(len(self.__levels)): self.__levels[i].load() else: rsp = Net.send(Commands.GetChapter(self.hash)).response for key in list(rsp.keys()): self.get_level_by_hash(key).parse(rsp[key])
def get_friend_score(self, friend): """ :return: Friend's score. :rtype: int """ self.__client.add_friends(friend) friend = self.__client.get_friend(friend) rsp = Net.send(Commands.QueryUsersLevels(self.__client.session, [self.qualified_id], [friend.user_id])) if self.qualified_id in rsp and friend.user_id in rsp[self.qualified_id]: return rsp[self.qualified_id][friend.user_id] return 0
def lose(self, completion=None, boosters=None): """ Attemps to lose level. :return: True in case of success, False otherwise. :rtype: bool """ if completion is None: completion = None if boosters is not None: for booster in boosters: if not isinstance(booster, Boosters.Booster): booster = self.__client.boosters[booster] if booster.count == 0: booster.buy() booster.spend() cmd = Commands.LoseLevelCommand(self.__client, self.qualified_id, completion, boosters) Net.send(cmd) return not cmd.rejected
def load(self): if str(self.__client.network) != "device": """ Loads storage data. """ rsp = Net.send(Commands.FetchStorage(self.__client.storage_session, self.__client.session)).response self.__loaded = True self.__lock() self.merge(rsp["data"]) self.__unlock() else: self.__loaded = True self.__lock() self.merge({}) self.__unlock()
def buy(self, count=1): """ Attempts to buy a booster pack. :param count: A number of packs to buy. :return: True in case of success, False otherwise. :rtype: bool """ packs_count = self.__convert_count(count) for i in range(packs_count): cmd = Net.send(Commands.BuyBoosterCommand(self.__client, self.__type)) if cmd.rejected: return False return True
def read(self): """ Marks message as read. """ return not Net.send(Commands.ReadMessageCommand(self.__client, self.__id)).rejected
class GameScene(Scene): def __init__(self, music, host): super(GameScene, self).__init__() self.background = Surface((WINDOW_WIGTH, WINDOW_HEIGHT)) self.background.fill(Color(BACKGROUND_COLOR)) timer = pygame.time.Clock() self.music = music self.enemy = [] self.net=Net() self.net.subscribe(self.sync) self.host = host mouse.set_pos([200, 300]) self.heroes = [] self.up = self.down = self.left = self.right = False self.entitles_walls = pygame.sprite.Group() self.entitles = pygame.sprite.Group() self.addHero(Player(300, 55, 1)) self.walls = [] #map: self.map = open("maps/testmap.txt", "r") self.x = 0 self.y = 0 self.lenx = 0 self.leny = 0 for self.row in self.map: for self.col in self.row: if self.col == "-": self.wall = wall(self.x, self.y) self.entitles_walls.add(self.wall) self.walls.append(self.wall) if self.col == " ": self.floor = floor1(self.x, self.y) self.entitles_walls.add(self.floor) self.x = self.x + BLOCK_X self.y = self.y + BLOCK_Y self.lenx = self.x / BLOCK_X self.leny += 1 self.x = 0 for i in self.heroes: self.entitles.add(i) total_level_width = self.lenx*WINDOW_WIGTH total_level_height = self.leny*WINDOW_HEIGHT self.camera = Camera(camera_configure, total_level_width, total_level_height) self.enemy = [] if self.host: self.enemy = [Enemy(100, 100, 1), Enemy(200, 200, 2), Enemy(100, 500, 3)] for i in self.enemy: self.entitles.add(i) self.bul = [] self.bul.append(Bullet(0,0)) if self.music == True: pygame.mixer.music.load("music/Game.mp3") pygame.mixer.music.play(-1) def render(self, screen): screen.blit(self.background, (0, 0)) for i in self.entitles_walls: screen.blit(i.image, self.camera.apply(i)) for i in self.entitles: screen.blit(i.image, self.camera.apply(i)) def update(self, dt): self.send_sync(self.net) self.heroes[0].update(self.up, self.down, self.left, self.right, self.walls, dt) for i in self.enemy: i.update(self.walls, self.heroes, self.bul, dt) if i.hp == 0: self.enemy.remove(i) del i for i in self.bul: i.update(self.walls, dt) if i.col == True: self.bul.remove(i) del i self.camera.update(self.heroes[0]) for i in self.entitles: if i.par == "bul": if i.col == True: self.entitles.remove(i) if i.par == "enemy" or i.par == "player": if i.hp == 0: self.entitles.remove(i) if self.heroes[0].hp == 0: if self.music == True: pygame.mixer.music.stop() self.manager.go_to(LoseScreen()) def handle_events(self, events): for event in events: if event.type == KEYDOWN and (event.key == K_UP or event.key == K_w): self.up = True if event.type == KEYUP and (event.key == K_UP or event.key == K_w): self.up = False if event.type == KEYDOWN and (event.key == K_DOWN or event.key == K_s): self.down = True if event.type == KEYUP and (event.key == K_DOWN or event.key == K_s): self.down = False if event.type == KEYDOWN and (event.key == K_LEFT or event.key == K_a): self.left = True if event.type == KEYUP and (event.key == K_LEFT or event.key == K_a): self.left = False if event.type == KEYDOWN and (event.key == K_RIGHT or event.key == K_d): self.right = True if event.type == KEYUP and (event.key == K_RIGHT or event.key == K_d): self.right = False if event.type == MOUSEBUTTONDOWN and event.button == 1: self.bul.append(Bullet(self.heroes[0].rect.x, self.heroes[0].rect.y)) self.entitles.add(self.bul[len(self.bul)-1]) if event.type == KEYDOWN and event.key == K_ESCAPE: if self.music == True: pygame.mixer.music.stop() self.heroes[0].hp = 0 self.manager.go_to(LoseScreen()) def find_unit_by_uid(self, uid): for u in self.heroes: if u.uid == uid: return u if not(self.host): for u in self.enemy: if u.uid == uid: return u def addHero(self, u): self.heroes.append(u) self.entitles.add(u) def addEnemy(self, u): self.enemy.append(u) self.entitles.add(u) def sync(self, message, channel): u = self.find_unit_by_uid(message["uid"]) if (u): if u.local and u.par == "player": u.set_pos(message['x'], message['y'], message['ang'], message['hp']) if u.par == "enemy": u.set_pos(message['x'], message['y'], message['hp']) else: if message['par'] == 'player' and message['hp'] > 50: u = Player(message['x'], message['y'], 2, uid = message['uid']) self.addHero(u) self.heroes[1].local = True if not(self.host): if (message['par'] == 'enemy') and message['hp'] > 2: u = Enemy(message['x'], message['y'], message['type'], uid = message['uid']) self.addEnemy(u) def send_sync(self, net): for u in self.heroes: if not(u.local): message = { 'uid': u.uid, 'par': u.par, 'x': u.rect.x, 'y': u.rect.y, 'ang': u.angle, 'hp': u.hp} net.publish(message) for u in self.enemy: if not(u.local): message = { 'uid': u.uid, 'par': u.par, 'type': u.ztype, 'hp' : u.hp, 'x': u.rect.x, 'y': u.rect.y} net.publish(message)
def load(self): """ Loads level from server. """ self.parse(Net.send(Commands.GetLevel(self.hash)).response)
# coding=utf-8 #!/usr/bin/python import os import shutil import compileall import Net # print os.path.dirname(__file__) # if(os.getcwd() != os.path.dirname(__file__)): # os.chdir(os.path.dirname(__file__)) # print os.getcwd() # compileall.compile_dir(os.path.dirname(__file__)) Net.main("..\..\..\Doc\in", "..\..\Assets\Scripts\Network\Dispatcher")
def delete(self): """ Deletes message from inbox. """ return not Net.send(Commands.DeleteMessagesCommand(self.__client, [self.__id])).rejected