游戏开发中的事件机制Java实现

游戏开发中，游戏逻辑往往很复杂，互相交织在一起，需要开发者进行良好的设计加以维护。因此运用一定的设计模式往往能起到良好的效果。


最近在使用Java开发一款安卓游戏的时候，设计并实现了一套事件处理机制，用以分离游戏逻辑中的关注点，提升游戏的维护性和扩展性。
其实现仅仅为一个Java文件，代码仅150行左右，并不依赖于任何外部库和游戏引擎，只要编程环境为Java，并且你的游戏框架是基于游戏循环机制，就能使用。
该实现非常轻量级，我不保证其效率和设计在任何一个款游戏设计中都能很好的运用，但是至少在我的游戏里它一直工作的很好，也帮助我解决了不少设计问题，所以仅供学习分享。

同时它并不是线程安全的，所以请确保在同一个线程调用方法。如果你需要多线程安全，可以改写它。但根据我的经验，很少需要多线程这种情况。

使用说明：

1、首先需要创建RootEventManager（EventManager的内部类，同时也继承于EventManager）

2、EventManager通过方法setParentEventManager可以组织成树状结构，但是RootEventManager对象必须作为根节点

3、在游戏的循环中调用RootEventManager的onUpdate()方法

4、接下来就可以在各个EventManager里面注册监听器（IEventListener）以及监听规则，可以按Event的类型、事件源、事件源类型、事件标示过滤需要接受的事件。

5、通过EventManager的postEvent方法可以派发事件，子EventManager的事件会派发到父EventManager中。

6、CauseEvent是事件的引发关系，类似异常链，如果不需要的话置为null

可能说的比较笼统，大家可以直接看源码体会，源码利用泛型和反射机制，也是不错的示范学习材料。

附上源码：

package cn.edu.zucc.util.event;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;

public class EventManager {

	static public class RootEventManager extends EventManager {
		public void onUpdate() {
			super.onUpdate();
		}
	}
	
	private HashMap<IEventListener<?>, Object[]> mEventListenerRegisterMap = new HashMap<IEventListener<?>, Object[]>();
	private Queue<IEvent<?, ?>> mEventQueue = new LinkedList<IEvent<?, ?>>();
	private List<EventManager> mChildrenEventManager = new ArrayList<EventManager>();
	private EventManager mParentEventManager;
	
	public void postEvent(final IEvent<?, ?> pEvent){
		if(pEvent == null) return;
		mEventQueue.offer(pEvent);
		if(mParentEventManager != null) mParentEventManager.postEvent(pEvent);
	}

	@SuppressWarnings("unchecked")
	private void onUpdate() {
		 IEvent<?, ?> event = mEventQueue.poll();
         Object source;
         Class<? extends Object> sourceClass;
         Class<? extends IEvent<?, ?>> eventClass;
         int eventFlag;
         while(event != null){
                 Map<IEventListener<?>, Object[]> eventListenerRegisterMap 
                         = (Map<IEventListener<?>, Object[]>) mEventListenerRegisterMap.clone();
                 Set<Entry<IEventListener<?>, Object[]>> entrys = eventListenerRegisterMap.entrySet();
                 for(Entry<IEventListener<?>, Object[]> entry : entrys){
                         Object[] info = entry.getValue();
                         IEventListener<IEvent<?, ?>> eventListener = (IEventListener<IEvent<?, ?>>) entry.getKey();
                         source = info[0];
                         sourceClass = (Class<? extends Object>) info[1];
                         eventClass = (Class<? extends IEvent<?, ?>>) info[2];
                         eventFlag = (Integer) info[3];
                         if((source == null || event.getSource() == source)
                                         && (sourceClass == null || sourceClass.isAssignableFrom(event.getSource().getClass()))
                                         && (eventFlag == 0 || event.getEventFlag() == eventFlag)
                                         && (eventClass == null 
                                                 || eventClass.isAssignableFrom(event.getClass()))){
                                 eventListener.onAction(event, this);
                         }
                 }
                 event = mEventQueue.poll();
         }
         for(EventManager childEventManager : mChildrenEventManager){
 			childEventManager.onUpdate();
 		}
	}

	public interface IEventListener<E extends IEvent<?, ?>>{
		void onAction(E pEvent, EventManager pEventManager);
	}

	public interface IEvent<S, E extends IEvent<?, ?>>{
		Object getSource();
		int getEventFlag();
		E getCauseEvent();
	}

	static abstract public class BaseEvent<S, E extends IEvent<?, ?>> implements IEvent<S, E>{
		private S mSource;
		private int mEventFlag;
		private E mCauseEvent;

		public BaseEvent(final S pSource, int pEventFlag, E pCauseEvent){
			mSource = pSource;
			mEventFlag = pEventFlag;
			mCauseEvent = pCauseEvent;
		}

		public BaseEvent(final S pSource, E pCauseEvent){
			this(pSource, 0, pCauseEvent);
		}

		public BaseEvent(final S pSource, int pEventFlag){
			this(pSource, pEventFlag, null);
		}
		public BaseEvent(final S pSource){
			this(pSource, 0);
		}
		@Override
		public S getSource() {
			return mSource;
		}
		@Override
		public int getEventFlag() {
			return mEventFlag;
		}

		@Override
		public E getCauseEvent() {
			return mCauseEvent;
		}		
	}

	public void registerEventListenerByEventClass(final IEventListener<? extends IEvent<?, ?>> pEventListener
			, final Class<? extends IEvent<?, ?>> pEventClass){
		registerEventListener(pEventListener, pEventClass, 0, null, null);
	}

	public void registerEventListenerByEventFlag(final IEventListener<IEvent<?, ?>> pEventListener
			, final int pEventFlag){
		registerEventListener(pEventListener, null, pEventFlag, null, null);
	}

	public void registerEventListenerBySourceClass(final IEventListener<IEvent<?, ?>> pEventListener
			, final Class<? extends Object> pSourceClass){
		registerEventListener(pEventListener, null, 0, pSourceClass, null);
	}

	public void registerEventListenerBySource(final IEventListener<IEvent<?, ?>> pEventListener
			, final Object pSource){
		registerEventListener(pEventListener, null, 0, null, pSource);
	}

	public void registerEventListener(final IEventListener<?> pEventListener
			, final Class<? extends IEvent<?, ?>> pEventClass
					, final int pEventFlag
					, final Class<? extends Object> pSourceClass
					, final Object pSource){
		mEventListenerRegisterMap.put(pEventListener, new Object[]{pSource, pSourceClass, pEventClass, pEventFlag});
	}

	public void unregisterEventListener(final IEventListener<?> pEventListener){
		mEventListenerRegisterMap.remove(pEventListener);
	}

	public void cleanEventListener(){
		mEventListenerRegisterMap.clear();
	}
	
	public void setParentEventManager(EventManager pParentEventManager){
		if(mParentEventManager != null)
			mParentEventManager.mChildrenEventManager.remove(this);
		if(pParentEventManager != null) pParentEventManager.mChildrenEventManager.add(this);
		mParentEventManager = pParentEventManager;
	}


}