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 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
