It looks like rotation values calculated are aditionally and can be greater then 360. Maybe it is usefull to integrate a limit like

if (rotation.y > 360)
{ 
rotation.y = 0
}
if(rotation.y < 0)
{
rotation.y = 360
}

Mô tả

• Mỗi MMORoomGroup là 1 container chứa một số MMORoom
• Mỗi MMORoomGroup nằm trên 1 thread riêng
• Có 1 vòng lặp tick time, mỗi time unit sẽ gọi update các room trong group

Cài đặt

MMORoomGroup

• Tạo lớp MMORoomGroup:

public class MMORoomGroup {

	private volatile boolean active;
	private Map<String, MMORoom> roomMap = new HashMap<>();

	public MMORoomGroup() {
		new Thread(() -> {
			while (active) {
				for each room in rooms:
					room.update(); 

				Thread.sleep(100);
			}
		}).start();
	}

	public void destroy() {
		active = false;
	}

	public void addRoom(MMORoom room) {
		rooms.put(room.getName(), room);
	}

	public void removeRoom(MMORoom room) {
		removeRoom(room.getName());
	}

	public void removeRoom(String roomName) {
		rooms.remove(roomName)
	}
}

Viết test

• Viết các lớp unitest tương ứng

Câu hỏi

• Logic tạo threads cho MMORoom và LocatedRoom khác gì nhau vậy ạ?

Mô tả

• Khởi tạo 2 x nCores MMORoomGroup ở hàm start()

Cài đặt

MMOVirtualWorld

• Tạo lớp MMOVirtualWorld:

public class MMOVirtualWorld extends EzyLoggable {
	
	private final static int N_CORES = Runtime.getRuntime().availableProcessors();
	private final Map<String, MMORoomGroup> groupMap = new ConcurrentHashMap<>();
	private EzyWrap<String> groupThreadNameBuffer = new EzyWrap<>();
	private final int nMMORoomGroups;
	private final int timeTickMillis;
	
	public MMOVirtualWorld(Builder builder) {
		this.nMMORoomGroups = N_CORES * 2;
		this.timeTickMillis = builder.timeTickMillies;
		this.start();
	}
	
	private void start() {
		for (int i = 0; i <= nMMORoomGroups; i++) {
			MMORoomGroup group = MMORoomGroup.builder()
					.timeTickMillies(timeTickMillis)
					.build();
			group.getThreadName(groupThreadNameBuffer);
			groupMap.put(groupThreadNameBuffer.getValue(), group);
		}
	}
	
	public static Builder builder() {
		return new Builder();
	}
	
	public static class Builder implements EzyBuilder<MMOVirtualWorld> {
		private int timeTickMillies;
		
		public Builder timeTickMillies(int timeTickMillies) {
			this.timeTickMillies = timeTickMillies;
			return this;
		}
		
		@Override
		public MMOVirtualWorld build() {
			return new MMOVirtualWorld(this);
		}
	}
}

Viết test

• Viết các lớp unitest tương ứng

Câu hỏi

• MMOVirtualWorld có cần quản lý các groups không, hay chỉ cần khởi tạo các group là được vậy ạ?

Có 2 cái managers này sẽ rất tiện cho việc query players và rooms

[ x ] 1. Thêm hàm maxPlayer vào MMORoom.Builder
[ x ] 2. Thêm trường master vào MMORoom
[ ] 3. playerManager, roomManager cho MMOVirtualWorld --> globalPlayerManager, globalRoomManager --> Issue #20
[ x ] 4. Sửa lại MMORoomGroup.sleep phải tính khoảng sleep time còn lại thay vì sleep đúng bằng time tick. Vì nếu việc tính toán chậm sẽ làm delay tích tụ dần
[ x ] 5. Bổ sung clientTimeTick vào MMOPlayer
[ ] 6. Xem xét xem có cách nào để làm logic tìm room master của LocatedRoom đơn giản hơn không --> Issue #21
[ x ] 7. Bổ sung các vector đơn vị Vec3.left, Vec3.right, Vec3.up, Vec3.down
[ x ] 8. final private List nearbyPlayerNamesBuffer

@vu-luong Anh đang định nhờ em chỗ này. :)

Logic của việc tìm thằng master là phải tìm ra thằng ngội cạnh nó nhất, ví dụ 1 bàn chơi poker chẳng hạn, giả sử có 3 người chơi:

case1: ghế 1 (user1) - ghế 2 (trống) - ghế 3 (user2) - ghế 4 (trống) - ghế 5 (trống) - ghế 6 (user3), thì khi user2 thoát thì thằng gần nhất nó là user1 sẽ thành master.

case1: ghế 1 (user1) - ghế 2 (trống) - ghế 3 (trống) - ghế 4 (user2) - ghế 5 (trống) - ghế 6 (user3), thì khi user1 thoát thì thằng gần nhất nó là user3 sẽ thành master.

Hiện tại anh đang không muốn dùng sort vì anh muốn 1 performance tốt hơn, nên anh đang code kiểu lấy 1 điểm ở đâu đó rồi tính khoảng cách xem thằng nào gần thằng master mới thoát nhất thì update, nhưng có vẻ phức tạp quá và dễ bug, em xem có cách nào đơn giản hơn không nhé, nếu phức tạp quá em thử dùng sort xem sao nhé.

• Sử dung ArrayList thay vì LinkedList trong trường hợp chỉ cần add và read
• Sử dụng Set hoặc Map thay cho List trong trường hợp không quan tâm đến thứ tự (index) và có add và remove

Mô tả

• Tự động sync position sau khi room updated nếu dev không có ý kiến gì

Cài đặt

SyncPositionRoomUpdatedHandler

• Tạo lớp SyncPositionRoomUpdatedHandler extends MMORoomUpdateHandler, implement method onRoomUpdated

@Override
public void onRoomUpdated(MMORoom room) {
      for each player in room:
            responseFactory.newArrayResponse()
                  .command(Commands.SYNC_POSITION)
                  .data(player.getPosition())
                  .usernames(nearbyPlayers) // chỉ gửi request đến những thằng nearby
                  .execute();
}

Viết test

• Viết các lớp unitest tương ứng

Câu hỏi

• Làm sao để thằng SyncPositionRoomUpdatedHandler là mặc định?

Mô tả

** Chi tiết tham khảo tại: http://docs2x.smartfoxserver.com/AdvancedTopics/mmo-rooms

• Cho phép nhiều người tham gia vào một room
• Room sẽ được tổ chức theo dạng map, mỗi người sẽ một vị trí trong map và vị trí này có thể có thể thay đổi theo client gửi lên

Cài đặt

MMOPlayer

Tạo lớp MMOPlayer extends Player, bổ sung các trường:

• position: Vec3
• rotation: Rotate(x, y, z) : đây là hướng của player, cái này client sẽ dùng để hiển thị, còn server sẽ dùng để verify vị trí mà client gửi lên

MMORoom

Tạo lớp MMORoom thừa kế lớp Room, lớp này sẽ có 1 hàm start gọi đến một vòng loop kiểu

while(active) {
 for(player: players) {
    for(other : players {
       if(other != player) {
         if(other is near by) {
             player.addNearByPlayer(other)
        }
      }
    }
 }
}

Viết test

Viết các lớp unitest tương ứng

• Các ReadOnly Collection có thể dẫn đến lỗi concurrent modification trong môi trường đa luồng
• Các ReadOnly Collection bằng unmodified collection mặc định của java

Em nghĩ mình nên để cả player trong player.nearbyPlayers, tức là bỏ chỗ check if (!other.equals(player)). Mục đích là để thông báo cho chính player khi nó có sự thay đổi vị trí.