static public DataFactory createFactory(Type classType, DATA_TYPE type)
{
object[] param = new object[] { type, classType }; //构造器参数
DataFactory factory = UnityUtility.createInstance <DataFactory>(typeof(DataFactory), param);
return(factory);
}
//------------------------------------------------------------------------------------------------------------
protected SocketPacket createPacket(Type classType, PACKET_TYPE packetType)
{
SocketPacket packet = UnityUtility.createInstance <SocketPacket>(classType, packetType);
packet.init();
return(packet);
}
public static SceneProcedure createProcedure <T>(GameScene gameScene, PROCEDURE_TYPE type) where T : SceneProcedure, new()
{
object[] procedureParams = new object[] { type, gameScene };
T procedure = UnityUtility.createInstance <T>(typeof(T), procedureParams);
return(procedure);
}
public virtual Data createData()
{
object[] param = new object[] { mType }; //构造器参数
Data data = UnityUtility.createInstance <Data>(mClassType, param);
return(data);
}
public SocketPacket createPacket()
{
object[] param = new object[] { mType }; //构造器参数
SocketPacket pack = UnityUtility.createInstance <SocketPacket>(mClassType, param);
return(pack);
}
protected void registeComponent <T>() where T : FrameComponent
{
string name = typeof(T).ToString();
T component = UnityUtility.createInstance <T>(typeof(T), name);
mFrameComponentMap.Add(name, component);
mFrameComponentList.Add(component);
}
public SocketPacket createPacket(Type type)
{
if (mClassTypeList.ContainsKey(type))
{
return(UnityUtility.createInstance <SocketPacket>(type, mClassTypeList[type].mType));
}
return(null);
}
public SocketPacket createPacket(PACKET_TYPE type)
{
if (mPacketTypeList.ContainsKey(type))
{
return(UnityUtility.createInstance <SocketPacket>(mPacketTypeList[type].mClassType, type));
}
return(null);
}
public SerialPortPacket createPacket(COM_PACKET type)
{
if (mComPacketRegisteList.ContainsKey(type))
{
return(UnityUtility.createInstance <SerialPortPacket>(mComPacketRegisteList[type], type));
}
return(null);
}
public SocketPacket createPacket(SOCKET_PACKET type)
{
if (mSocketPacketTypeList.ContainsKey(type))
{
PacketInfo info = mSocketPacketTypeList[type];
return(UnityUtility.createInstance <SocketPacket>(mSocketPacketTypeList[type].mClassType, info.mType, info.mDataCount));
}
return(null);
}
protected PlayerState createState(PLAYER_STATE type)
{
if (!mStateTypeList.ContainsKey(type))
{
UnityUtility.logError("state not registed! type : " + type);
return(null);
}
PlayerState state = UnityUtility.createInstance <PlayerState>(mStateTypeList[type], type);
return(state);
}
public static GameComponent createIndependentComponent(string name, Type type, bool initComponent = true)
{
GameComponent component = UnityUtility.createInstance <GameComponent>(type, type, name);
// 创建组件并且设置拥有者,然后初始化
if (initComponent && component != null)
{
component.init(null);
}
return(component);
}
public static GameComponent createIndependentComponent(string name, Type type, bool initComponent = true)
{
object[] constructParms = new object[] { type, name }; //构造器参数
GameComponent component = UnityUtility.createInstance <GameComponent>(type, constructParms);
// 创建组件并且设置拥有者,然后初始化
if (initComponent && component != null)
{
component.init(null);
}
return(component);
}
//------------------------------------------------------------------------------------------------------------
public void registerPacket <T>(PACKET_TYPE type) where T : SocketPacket
{
PacketInfo info = new PacketInfo();
info.mClassType = typeof(T);
info.mType = type;
SocketPacket packet = UnityUtility.createInstance <T>(typeof(T), type);
info.mPacketSize = packet.getSize();
mPacketTypeList.Add(type, info);
mClassTypeList.Add(info.mClassType, info);
}
// 注册时可以指定组件的初始化顺序,更新顺序,销毁顺序
protected void registeFrameSystem(Type type, int initOrder = -1, int updateOrder = -1, int destroyOrder = -1)
{
string name = type.ToString();
var component = UnityUtility.createInstance<FrameSystem>(type);
component.setName(name);
component.setInitOrder(initOrder == -1 ? mFrameComponentMap.Count : initOrder);
component.setUpdateOrder(updateOrder == -1 ? mFrameComponentMap.Count : updateOrder);
component.setDestroyOrder(destroyOrder == -1 ? mFrameComponentMap.Count : destroyOrder);
mFrameComponentMap.Add(name, component);
mFrameComponentInit.Add(component);
mFrameComponentUpdate.Add(component);
mFrameComponentDestroy.Add(component);
}
// 注册时可以指定组件的初始化顺序,更新顺序,销毁顺序
protected void registeComponent <T>(int initOrder = -1, int updateOrder = -1, int destroyOrder = -1) where T : FrameComponent
{
string name = typeof(T).ToString();
T component = UnityUtility.createInstance <T>(typeof(T), name);
component.mInitOrder = initOrder == -1 ? mFrameComponentMap.Count : initOrder;
component.mUpdateOrder = updateOrder == -1 ? mFrameComponentMap.Count : updateOrder;
component.mDestroyOrder = destroyOrder == -1 ? mFrameComponentMap.Count : destroyOrder;
mFrameComponentMap.Add(name, component);
mFrameComponentInit.Add(component);
mFrameComponentUpdate.Add(component);
mFrameComponentDestroy.Add(component);
}
public static HttpPacket createPacket(string address)
{
HTTP_PACKET typePacket = HTTP_PACKET.HP_NONE;
if (PacketAdressList.ContainsKey(address))
{
typePacket = PacketAdressList[address];
}
if (typePacket != HTTP_PACKET.HP_NONE)
{
Type typeT = Type.GetType(PacketTypeList[typePacket]);
object[] tParams = new object[] { typePacket, address };
HttpPacket newPacket = UnityUtility.createInstance <HttpPacket>(typeT, tParams);
return(newPacket);
}
return(null);
}
public Command newCmd(Type type, bool show = true, bool delay = false)
{
mNewCmdLock.waitForUnlock();
// 首先从未使用的列表中获取,获取不到再重新创建一个
Command cmd = null;
if (mUnusedList.ContainsKey(type))
{
if (mUnusedList[type].Count > 0)
{
cmd = mUnusedList[type][0];
// 从未使用列表中移除
removeUnuse(cmd);
}
}
// 没有找到可以用的,则创建一个
if (cmd == null)
{
cmd = UnityUtility.createInstance <Command>(type);
cmd.setID(mIDSeed++);
cmd.init();
cmd.setType(type);
++mNewCount;
}
// 设置为可用命令
cmd.setValid(true);
if (delay)
{
cmd.setAssignID(mAssignIDSeed++);
}
else
{
cmd.setAssignID(-1);
}
cmd.setShowDebugInfo(show);
cmd.setDelayCommand(delay);
// 加入已使用列表
addInuse(cmd);
mNewCmdLock.unlock();
return(cmd);
}
// 创建一个道具
public SceneItemBase createItem(SCENE_ITEM type, ItemParamBase param)
{
if (!mItemRegisteList.ContainsKey(type))
{
return(null);
}
SceneItemBase item = UnityUtility.createInstance <SceneItemBase>(mItemRegisteList[type], type);
item.init(param);
if (mItemList.ContainsKey(type))
{
mItemList[type].Add(item);
}
else
{
List <SceneItemBase> itemList = new List <SceneItemBase>();
itemList.Add(item);
mItemList.Add(type, itemList);
}
return(item);
}
//----------------------------------------------------------------------------------------------
protected GameScene createScene(GAME_SCENE_TYPE type)
{
Type classType = mGameSceneRegisteList[type];
return(UnityUtility.createInstance <GameScene>(classType, type, classType.ToString()));
}
//------------------------------------------------------------------------------------------------------------
protected SocketFactory createFactory(Type classType, PACKET_TYPE type)
{
return(UnityUtility.createInstance <SocketFactory>(typeof(SocketFactory), new object[] { classType, type }));
}
public LayoutScript createScript(string name, GameLayout layout)
{
return(UnityUtility.createInstance <LayoutScript>(mScriptRegisteList[layout.getType()], name, layout));
}
protected SceneInstance createScene(string sceneName)
{
return(UnityUtility.createInstance <SceneInstance>(mSceneRegisteList[sceneName], sceneName));
}
public static SceneProcedure createProcedure <T>(GameScene gameScene, PROCEDURE_TYPE type) where T : SceneProcedure
{
T procedure = UnityUtility.createInstance <T>(typeof(T), type, gameScene);
return(procedure);
}
protected Character createCharacter(CHARACTER_TYPE type, string name)
{
return(UnityUtility.createInstance <Character>(mCharacterRegisteList[type], type, name));
}
public Data createData(DATA_TYPE type)
{
return(UnityUtility.createInstance <Data>(mDataRegisteList[type], type));
}
//------------------------------------------------------------------------------------------------------------
protected ScriptFactory createFactory(Type classType, LAYOUT_TYPE type)
{
return(UnityUtility.createInstance <ScriptFactory>(typeof(ScriptFactory), new object[] { type, classType }));
}
public virtual LayoutScript createScript(GameLayout layout, string name)
{
object[] param = new object[] { mType, name, layout };
return(UnityUtility.createInstance <LayoutScript>(mClassType, param));
}
//----------------------------------------------------------------------------------------------------------------
protected PlayerItemBase createPlayerItem(PLAYER_ITEM type)
{
return(UnityUtility.createInstance <PlayerItemBase>(mRegisteList[type], type));
}