/*Program entrance*/
int main(int argc, char** argv)
{
key_t ipckey = ftok("/",999);
int shmid = shmget(ipckey,sizeof(struct tag),IPC_CREAT |0660);
strTag = (struct tag *)shmat(shmid,NULL,0);
strTag->str = (char *)malloc(10);
printf("malloc : %lx\n",(unsigned long)strTag->str);
pid_t pid = fork();
if(pid == 0)
{
create_base();
}
if(pid > 0 )
{
signal(SIGCHLD,sig_chld);
struct event_base *base = event_base_new();
struct timeval tv = {1,0};
struct event sig;
struct event sig1;
// struct event timeout;
// evtimer_assign(&timeout,base,timerout,&timeout);
// evtimer_add(&timeout,&tv);
evsignal_assign(&sig,base,SIGINT,sig_act,(void *)&sig);
evsignal_add(&sig,NULL);
evsignal_assign(&sig1,base,SIGUSR1,sig_act2,(void *)base);
evsignal_add(&sig1,NULL);
event_base_dispatch(base);
event_base_free(base);
shmdt(strTag);
shmctl(shmid,IPC_RMID,NULL);
}
return 0;
}
explicit direct3d9_graphic_system(const basic_window<Window> &window)
: width_(window.width()),
height_(window.height()),
base_(create_base()),
device_(create_device(window, base_)) {
init_device();
}
Message* GameMessage::create_game(unsigned short id)
{
Message* msg = NULL;
switch(id)
{
default:
return create_base(id);
case NMS_PING: { msg = new GameMessage_Ping(); } break;
case NMS_PONG: { msg = new GameMessage_Pong(); } break;
case NMS_SERVER_TYPE: { msg = new GameMessage_Server_Type(); } break;
case NMS_SERVER_TYPEOK: { msg = new GameMessage_Server_TypeOK(); } break;
case NMS_SERVER_PASSWORD: { msg = new GameMessage_Server_Password(); } break;
case NMS_SERVER_NAME: { msg = new GameMessage_Server_Name(); } break;
case NMS_SERVER_START: { msg = new GameMessage_Server_Start(); } break;
case NMS_SERVER_CHAT: { msg = new GameMessage_Server_Chat(); } break;
case NMS_SERVER_ASYNC: { msg = new GameMessage_Server_Async(); } break;
case NMS_SERVER_COUNTDOWN: { msg = new GameMessage_Server_Countdown(); } break;
case NMS_SERVER_CANCELCOUNTDOWN: { msg = new GameMessage_Server_CancelCountdown(); } break;
case NMS_PLAYER_ID: { msg = new GameMessage_Player_Id(); } break;
case NMS_PLAYER_NAME: { msg = new GameMessage_Player_Name(); } break;
case NMS_PLAYER_LIST: { msg = new GameMessage_Player_List(); } break;
case NMS_PLAYER_SETSTATE: { msg = new GameMessage_Player_Set_State(); } break;
case NMS_PLAYER_SET_NATION: { msg = new GameMessage_Player_Set_Nation(); } break;
case NMS_PLAYER_SET_TEAM: { msg = new GameMessage_Player_Set_Team(); } break;
case NMS_PLAYER_SET_COLOR: { msg = new GameMessage_Player_Set_Color(); } break;
case NMS_PLAYER_KICKED: { msg = new GameMessage_Player_Kicked(); } break;
case NMS_PLAYER_PING: { msg = new GameMessage_Player_Ping(); } break;
case NMS_PLAYER_NEW: { msg = new GameMessage_Player_New(); } break;
case NMS_PLAYER_READY: { msg = new GameMessage_Player_Ready(); } break;
case NMS_PLAYER_SWAP: { msg = new GameMessage_Player_Swap(); } break;
case NMS_MAP_INFO: { msg = new GameMessage_Map_Info(); } break;
case NMS_MAP_DATA: { msg = new GameMessage_Map_Data(); } break;
case NMS_MAP_CHECKSUM: { msg = new GameMessage_Map_Checksum(); } break;
case NMS_MAP_CHECKSUMOK: { msg = new GameMessage_Map_ChecksumOK(); } break;
case NMS_SERVER_NWF_DONE: { msg = new GameMessage_Server_NWFDone; } break;
case NMS_GAMECOMMANDS: { msg = new GameMessage_GameCommand; } break;
case NMS_PAUSE: { msg = new GameMessage_Pause; } break;
case NMS_SERVER_SPEED: { msg = new GameMessage_Server_Speed; } break;
case NMS_GGS_CHANGE: { msg = new GameMessage_GGSChange; } break;
case NMS_REMOVE_LUA: { msg = new GameMessage_RemoveLua; } break;
case NMS_GET_ASYNC_LOG: { msg = new GameMessage_GetAsyncLog(); } break;
case NMS_SEND_ASYNC_LOG: { msg = new GameMessage_SendAsyncLog(); } break;
case NMS_SYSTEM_CHAT: { msg = new GameMessage_System_Chat(); } break;
}
return msg;
}
/**************************************************************************
Create a new base.
**************************************************************************/
void api_actions_create_base(Tile *ptile, const char *name, Player *pplayer)
{
struct base_type *pbase;
if (!name) {
return;
}
pbase = find_base_type_by_rule_name(name);
if (pbase) {
create_base(ptile, pbase, pplayer);
}
}
static void timerout2(evutil_socket_t fd, short events, void *arg)
{
printf("creat a child\n");
pid_t pid = fork();
if(pid == 0)
{
printf("%p\n",arg);
create_base();
printf("pid %d exit!!!\n",getpid());
exit(-1);
}
else
{
// event_free(arg);
printf("%p\n",arg);
return;
}
}
static void sig_act2(evutil_socket_t fd, short events, void *arg)
{
printf("creat a child\n");
pid_t pid = fork();
if(pid == 0)
{
create_base();
printf("ppid %d,pid %d exit!!!\n",getppid(),getpid());
exit(-1);
}
else
return;
/*
struct timeval tv = {2,0};
struct event *timeout;
timeout = evtimer_new(arg,timerout2,timeout);
evtimer_add(timeout,&tv);
*/
}
/**
*
*
* @author FloSoft
*/
Message* LobbyMessage::create_lobby(unsigned short id)
{
Message* msg = NULL;
switch(id)
{
default:
return create_base(id);
case NMS_LOBBY_LOGIN: { msg = new LobbyMessage_Login(); } break;
case NMS_LOBBY_LOGIN_DONE: { msg = new LobbyMessage_Login_Done(); } break;
case NMS_LOBBY_LOGIN_ERROR: { msg = new LobbyMessage_Login_Error(); } break;
case NMS_LOBBY_REGISTER: { msg = new LobbyMessage_Register(); } break;
case NMS_LOBBY_REGISTER_DONE: { msg = new LobbyMessage_Register_Done(); } break;
case NMS_LOBBY_REGISTER_ERROR: { msg = new LobbyMessage_Register_Error(); } break;
case NMS_LOBBY_SERVERLIST: { msg = new LobbyMessage_ServerList(); } break;
case NMS_LOBBY_SERVERINFO: { msg = new LobbyMessage_ServerInfo(); } break;
case NMS_LOBBY_RANKINGLIST: { msg = new LobbyMessage_RankingList(); } break;
case NMS_LOBBY_PLAYERLIST: { msg = new LobbyMessage_PlayerList(); } break;
case NMS_LOBBY_ID: { msg = new LobbyMessage_Id(); } break;
case NMS_LOBBY_CHAT: { msg = new LobbyMessage_Chat(); } break;
case NMS_LOBBY_PING: { msg = new LobbyMessage_Ping(); } break;
case NMS_LOBBY_PONG: { msg = new LobbyMessage_Pong(); } break;
case NMS_LOBBY_SERVER_ADD: { msg = new LobbyMessage_Server_Add(); } break;
case NMS_LOBBY_SERVER_ADD_FAILED: { msg = new LobbyMessage_Server_Add_Failed(); } break;
case NMS_LOBBY_SERVER_DELETE: { msg = new LobbyMessage_Server_Delete(); } break;
case NMS_LOBBY_SERVER_UPDATE_PLAYER: { msg = new LobbyMessage_Server_Update_Player(); } break;
case NMS_LOBBY_SERVER_UPDATE_MAP: { msg = new LobbyMessage_Server_Update_Map(); } break;
case NMS_LOBBY_SERVER_JOIN: { msg = new LobbyMessage_Server_Join(); } break;
case NMS_LOBBY_RANKING_INFO: { msg = new LobbyMessage_Lobby_Ranking_Info(); } break;
}
return msg;
}
VCOS_STATUS_T _vcos_thread_create_attach(VCOS_THREAD_T *thread,
const char *name)
{
VCOS_STATUS_T status;
status = create_base(thread, name);
if (status != VCOS_SUCCESS)
goto fail_base;
status = _vcos_llthread_create_attach(&thread->thread);
if (status != VCOS_SUCCESS)
goto fail_llthread;
#ifdef VCOS_WANT_TLS_EMULATION
vcos_tls_thread_register(&thread->_tls);
#endif
return VCOS_SUCCESS;
fail_llthread:
delete_base(thread);
fail_base:
return status;
}
VCOS_STATUS_T vcos_thread_create(VCOS_THREAD_T *thread,
const char *name,
VCOS_THREAD_ATTR_T *attrs,
void *(*entry)(void *arg),
void *arg)
{
VCOS_STATUS_T status;
void *stack, *allocstack = 0;
/* If no attributes, use the defaults */
if (!attrs)
attrs = &default_attrs;
status = create_base(thread, name);
if (status != VCOS_SUCCESS)
goto fail_base;
/* Do we need to create a stack? */
stack = attrs->ta_stackaddr;
if (stack && !VCOS_CAN_SET_STACK_ADDR)
{
status = VCOS_EINVAL;
goto fail_stack;
}
if (!stack && VCOS_CAN_SET_STACK_ADDR)
{
allocstack = vcos_malloc(attrs->ta_stacksz,thread->name);
if (!allocstack)
{
status = VCOS_ENOMEM;
goto fail_stack;
}
stack = allocstack;
thread->stack = stack;
}
thread->legacy = attrs->legacy;
thread->entry = entry;
thread->arg = arg;
status = vcos_llthread_create(&thread->thread, thread->name, vcos_thread_wrapper, thread,
stack, attrs->ta_stacksz,
attrs->ta_priority, attrs->ta_affinity,
attrs->ta_timeslice, attrs->ta_autostart);
if (status != VCOS_SUCCESS)
goto fail_thread;
return VCOS_SUCCESS;
fail_thread:
if (allocstack)
vcos_free(allocstack);
fail_stack:
delete_base(thread);
fail_base:
return status;
}
