博客园_飞扬天下

我的网站,求友情链接

2011-11-03T09:40:00Z

http://www.iwinphone7.com/

Window Phone, Window Phone 7, Microsoft, Zune.

XAP

欢迎大家光临,互链请联系QQ:80531448,MSN:rise.worlds@live.com.

本文链接

成长之痛

2011-06-14T08:30:00Z

10号终于决定离开公司了，在这地方待了近四年的时间，历经项目开发的其中各种滋味。

在四年的时间中，搞不清楚自己到底成长多少，自己的器量有多大。

最后这段时间经常有公司的同事们用各种办法挽留，然而到最后自己也没能坚持下来。

成长过程中，要经的住诱惑，改变是必须的，但是不可避免地伴随着成长之痛。

自己还需要得到更多的磨练，更多的机会，才能成器。

万城不是一个适合做开发做团队做互联网的地方，

骨子里少互联网的团队那种该有的精神和目标，过多的是想依小求大，相互牵制，很多事情做的事得其反。
现在，对于有些事情、有些人也无心去评价，一切自有时间来证明。
而所有曾经在万城为同一个目标努力过的朋友，将成为我生命中不可磨灭的记忆，同时祝福所有人。
希望有一天可以组建自己的互联网团队，并取的一席之地。

也希望万城的复仇项目最终可以浴火重生，其它的项目可以进展顺利。

其时我更好看好其它项目，如果不是在这个环境下的话。

历经磨难方可救赎，感受悲苦便知甘甜。圣洁之火源于幽暗，涅磐之后得以重生。

本文链接

审核游戏功能

2011-02-20T09:45:00Z

1.什么是游戏功能
游戏功能即game feature，一个游戏的各个子系统。如法术系统，状态系统，天赋系统，包裹系统，P2P交易系统，修理系统，附魔系统等等。
游戏功能由策划进行设计，然后交给美术和程序执行。
2.什么是审核

审核是一个功能设计的过滤器，这种过滤针对设计的可执行性，而非功能本身。
3.为什么要审核
策划们不明白每个功能的执行优先级。程度：有时候。危害：功能做出来了，但是暂时成为了摆设。
策划们的设计文档是不够详细，不够完整，甚至有些细节还没有想清楚或者在自己的部门内达成一直认识的。程度：经常。危害：这种设计就是反复被变更和修改的那种设计，程序也会因此越改越烂，并且功能要拖拖拉拉好几个里程碑。
国内的公司都不怎么大，公司的法人会出来用独裁手段让大家执行某个功能。程度：偶尔。危害：说不准。
程序是食物链上的最后一环，如果前面没有把好关，那么后面就要拉肚子生病。
审核能过滤掉目标和受众不明确的功能。
审核能过滤掉设计不完整的功能。
审核能判断出功能的执行优先级。
4.审核的基本原则
因为我是一个程序，我也信任自己的策划同事，所以最基本的原则是，不对功能在设计上做任何评论和质疑。
审核只关心功能的目标，设计的信息完整性，和由此引申出来的可执行性。
审核没有通过并不会一棒子打死功能和设计，只要功能和设计能通过审核，就能被执行。
5.怎样审核
   5.1规则集合
规则集合是一组标准，只有一个功能的设计完全通过这组标准的时候，才能加入执行队列。
这组规则不是一个人建立的，而是所有有责任心的同事提出的意见中提炼出来了。
我先大概提出这么一些：
*功能必须为玩家的一个以上的生命期提供主要服务（新手期，兴奋期，参与沉迷期）
*功能必须针对一种类型以上的玩家（探索型，成就型，杀手型，社交型）
*功能支持零个以上的其他功能。
*功能依赖的其他功能必须已经实现。
*功能设计可以通过程序正常表现。
*功能设计中必须提供详细的美术需求。
*功能设计中的基本面必须完整。
*功能设计中必须拟定需要用到的数据表格。
   5.2审核小组
审核小组从同事中找5个人左右，各个部门都必须占有1个以上的席位。每个组员仅负责其中的几条规则，各个组员所负责的规则之间不能有交集。
每个组员用自己负责的规则对功能和设计做出通过和不通过的判断，并对不通过的的判断给出具体理由。
每个不通过的判断都必须得到组内3人以上（含3人）的认可。
   5.3审核过程
策划完成功能设计之后，必须提供一份针对审核规则的设计说明文档，以便于审核小组能迅速的判断出功能的设计是否能执行。
审核小组全员通过功能设计后，通过审核规则中的算法规则（我没有提供，因为这要考虑很多方面）计算功能的执行优先级，加入功能队列，由PM进行工作分配。
没能通过的功能设计，将包含一份详细的犯规细节清单还给策划。然后策划进行工作避开这些犯规后，可以再次提交审核。

本文链接

限时免费抢！正版卡巴斯基安全部队2011激活码1年

2010-11-05T01:15:00Z

最近互联网真是硝烟四起啊！趁着360与腾讯斗得你死我活的时候，卡巴斯基借机推出了“全民脱险”活动，免费向所有人赠送卡巴斯基安全部队2011正版一年激活码。鹬蚌相争，渔翁得利，估计卡巴是想将360流失的用户收拢了吧。不管怎样，对用户来说，能免费使用原本售价近200多元的杀毒软件，还是好事一件！

卡巴斯基作为老牌的杀毒软件大家都很熟悉了，这次安全部队2011版在功能和优化上都有了很大的提高，而且加强了对网银、网游的安全监管。性能方面，这次官方还直接宣传说“卡巴斯基再也不卡了！”，可见他们对这个版本的性能优化挺有信心的吧，喜欢卡巴的同学别浪费了这次免费的机会哟……

卡巴斯基安全部队2011安全堡垒功能

新版的卡巴斯基安全部队2011拥有非常多的改进，产品设计更加成熟，细节方面更加完善。区域过滤、程序管控、省电模式和增强版家长管控都为这款产品增色许多。反正大家对卡巴斯基其实都很熟悉了，一般的功能我就也不必费文字来描述了。这次2011相比以前，我认为最大特色就是加入了一个叫做“安全堡垒”的实用功能，就这一点就让我有使用它的冲动了。

安全堡垒类似于“影子系统”，为浏览器和其它应用程序提供了一个受保护的虚拟环境，以更好地保护系统和隐私数据安全。安全堡垒共分为三个小功能：安全桌面、安全浏览器和安全键盘，通过这三个功能的配合使用，可以非常有效地防止用户隐私数据被盗，系统被恶意修改等问题。

和影子系统类似，你可以在“安全桌面”里运行一些危险的程序或测试未知安全性的程序，不会对你的真实系统产生影响；同理，你可以在“安全浏览器”里测试访问危险的网站而不怕真实的系统受到任何影响了；而“安全键盘”就是能保护你在网银、或任何程序里输入账号密码的信息不被木马偷听或盗取。

写在后面：

总的来说，《卡巴斯基安全部队2011》作为卡巴斯基公司本年度最重磅级的产品，能免费提供1年的使用激活码，其实还算是比较厚道的了。喜欢卡巴的朋友要尽快抢了，因为这个免费活动到2010年12月3日就会结束。

申请卡巴斯基免费1年正版激活码：

活动时间：2010年11月4日至2010年12月3日
免费申请地址：http://song.kaba365.com/

本文链接

360与QQ共存方法

2010-11-04T01:09:00Z

狗咬狗，害了用户，但两个软件都有方便之处，所以共享的方法如下：
XP系统，在C:\Documents and Settings\你的用户名\Application Data\Tencent\QQ下，把SafeBase这个文件夹的权限设置为完全拒绝。
Vista\WIN7系统，在C:\Users\你的用户名\AppData\Roaming\Tencent\QQ下，把SafeBase这个文件夹的权限设置为完全拒绝。
TM版的，只是把文件夹QQ改为TM下的文件夹SafeBase权限为禁止。
这个safebase文件夹中显示的所有用户组，全部设为拒绝即可。
xp中，如果文件的选项卡中没安全选项，则，打开我的电脑，工具栏，文件夹选项，查看，在查看中把“使用简单文件共享（推荐）”勾去掉，就可以看到文件夹属性的“安全”选项卡。
-------------
此方法已测试。可行。
-------------
运行了五个小时之后的截图。二者均更新到最新版。

新增一张图:刚才刚则截的。

本文链接

微软Windows 7 SP1 RC 官方已经提供下载

2010-10-27T05:44:00Z

据国外媒体报道，来自国外媒体Neowin网站的消息称，目前，微软已经官方对外发布Windows 7 SP1的RC版本，版本号为windows6.1-KB976932。近段时间，Windows 7 SP1 RC版本的builds不断被泄露到网络中，可能就是由于这个原因微软才不得已提前对外Windows 7 SP1 RC版。

据了解，微软对外发布的Windows 7 SP1 RC包括32位和64位两个版本，64位版本的体积大小为865.4MB，32位版本的体积大小为514.7MB。微软表示，Windows 7 SP1将会包括Remote FX和Windows 7 RTM的累积更新与安全修复补丁。

通过安装Windows 7 SP1，用户将能够更加方便、快速地安装以往微软针对Windows 7 RTM发布的安全补丁和功能增强。

微软表示，所有运行正版Windows 7 RTM操作系统的用户都能够免费安装SP1。

RC候选版是最新的公开测试版本，这也就意味着距离正式的RTM版不远了。正如之前微软的声明，SP1中新增的功能只有与Windows Server 2008 R2相关的虚拟化技术：RemoteFX、动态内存（Dynamic Memory）。这些功能将帮助消费者通过虚拟桌面基础架构（Virtual Desktop Infrastructure，VDI）来部署Windows，并且获得可扩展和更加丰富的用户体验。

Windows 7 SP1则能帮助PC机利用上述基于服务器的功能，从而为终端用户提供更丰富的VDI体验。此外，SP1并没有新增专门针对Windows 7的功能。

最低系统要求：

— 1 GHz以上32位或64位处理器；

— 1GB RAM（32位）/2GB RAM（64位）；

— 16GB可用磁盘空间（32位）/20GB可用磁盘空间（64位）；

— DirectX 9图形处理器，WDDM 1.0或更高版本驱动；

— 兼容DVD；

Windows 7/Server 2008 R2 SP1 RC候选版下载页面（需注册）：

http://technet.microsoft.com/en-us/evalcenter/ff183870.aspx

用户可以通过以下链接去下载32位或64位的Windows 7 SP1 RC版本：
http://download.microsoft.com/download/0/A/F/0AFB5316-3062-494A-AB78-7FB0D4461357/windows6.1-KB976932-X86.exe
http://download.microsoft.com/download/0/A/F/0AFB5316-3062-494A-AB78-7FB0D4461357/windows6.1-KB976932-X64.exe
http://download.microsoft.com/download/0/A/F/0AFB5316-3062-494A-AB78-7FB0D4461357/7601.17105.100929-1730-3_Update_Sp_Wave1-RC1SP1.1_DVD.iso

本文链接

visual studio 中”error PRJ0003 : 生成 cmd.exe 时出错”

2010-10-19T08:18:00Z

刚装完VS2005，建了个Win32工程，一编译就出现 “项目 : error PRJ0003 : 生成“cmd.exe”时出错。”。

解决方案：工具—>选项—>项目和解决方案—>VC++目录，在可执行文件栏中加上如下路径：

$(SystemRoot)\System32
$(SystemRoot)
$(SystemRoot)\System32\wbem

现在运行成功了，输出内容：

------ 已启动生成: 项目: Game, 配置: Debug Win32 ------

正在嵌入清单...

生成日志保存在“file://e:\Visual Studio 2005\Projects\Game\Game\Debug\BuildLog.htm”

Game - 0 个错误，个警告

========== 生成: 成功1 个，失败0 个，最新0 个，跳过0 个==========

本文链接

Windows Live Essentials Wave 4 Beta 2 发布，附完整安装包下载

2010-08-18T01:05:00Z

微软今天宣布了 Windows Live Essentials Wave 4 的 Beta Refresh 版，也就是上次预告的 Beta 2。感谢 Damaster，新版 Essentials 安装包已经可以在下面的地址下载。

Windows Live Essentials Wave 4 Beta 2 更新包括：新增 Facebook Chat 的支持、Windows Live 照片库、Writer 和影音制作的一些改进和增强。我会在新文章中介绍，先下载安装吧。

对了，完整安装包共 151 MB，版本号 15.4.3001.0809：

英文版: Web 安装包 – 完整安装包
简体中文版: Web 安装包 – 完整安装包
法语版: Web 安装包 – 完整安装包
德语版: Web 安装包 – 完整安装包
荷兰语版: Web 安装包 – 完整安装包
葡萄牙语版（巴西）: Web 安装包 – 完整安装包
西班牙语版: Web 安装包 – 完整安装包
日语版: Web 安装包 – 完整安装包

[转载至]http://livesino.net/archives/2876.live

本文链接

Windows线程池Demo

2010-07-05T15:50:00Z

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

//
// Thread pool wait callback function template
//
VOID
    CALLBACK
    MyWaitCallback(
    PTP_CALLBACK_INSTANCE Instance,
    PVOID                 Parameter,
    PTP_WAIT              Wait,
    TP_WAIT_RESULT        WaitResult
    )
{
    //
    // Do something when the wait is over.
    //
    _tprintf(_T("MyWaitCallback: wait is over.\n"));
}

//
// Thread pool timer callback function template
//
VOID
    CALLBACK
    MyTimerCallback(
    PTP_CALLBACK_INSTANCE Instance,
    PVOID                 Parameter,
    PTP_TIMER             Timer
    )
{
    //
    // Do something when the timer fires.
    //
    _tprintf(_T("MyTimerCallback: timer has fired.\n"));

}

//
// This is the thread pool work callback function.
// The callback demonstrates correct behavior when changing the
// state of the thread inside the callback function.
//
// Any changes to the thread state must be restored to original
// before exiting the callback routine.
//
VOID
    CALLBACK
    MyWorkCallback(
    PTP_CALLBACK_INSTANCE Instance,
    PVOID                 Parameter,
    PTP_WORK              Work
    )
{
    BOOL bRet = FALSE;
    DWORD dwPriorityOriginal = 0;

    //
    // Record the original thread priority.
    //
    dwPriorityOriginal = GetThreadPriority(GetCurrentThread());

    if (THREAD_PRIORITY_ERROR_RETURN == dwPriorityOriginal) {
        _tprintf(_T("GetThreadPriority failed. LastError: %u\n"),
            GetLastError());
        return;
    }

    //
    // Increase the priority of the thread pool thread.
    //
    bRet = SetThreadPriority(GetCurrentThread(),
        THREAD_PRIORITY_ABOVE_NORMAL);

    if (FALSE == bRet) {
        _tprintf(_T("SetThreadPriority failed. LastError: %u\n"),
            GetLastError());
        return;
    }

_tprintf(_T("MyWorkCallback: thread priority increased.\n"));

    //
    // Perform tasks at increased priority.
    //
    {
        _tprintf(_T("MyWorkCallback: task performed at increased priority.\n"));

}

    //
    // Restore thread state by resetting the original priority.
    //
    bRet = SetThreadPriority(GetCurrentThread(),
        dwPriorityOriginal);

    //
    // If restore fails, maybe retry or throw an exception. Otherwise,
    // the thread will continue to execute other work items at increased
    // priority.
    //
    if (FALSE == bRet) {
        _tprintf(_T("Fatal Error! SetThreadPriority failed. LastError: %u\n"),
            GetLastError());
        return;
    }

_tprintf(_T("MyWorkCallback: thread priority restored.\n"));

return;
}

VOID
    DemoCleanupPersistentWorkTimer()
{
    BOOL bRet = FALSE;
    PTP_WORK work = NULL;
    PTP_TIMER timer = NULL;
    PTP_POOL pool = NULL;
    PTP_WORK_CALLBACK workcallback = MyWorkCallback;
    PTP_TIMER_CALLBACK timercallback = MyTimerCallback;
    TP_CALLBACK_ENVIRON CallBackEnviron;
    PTP_CLEANUP_GROUP cleanupgroup = NULL;
    FILETIME FileDueTime;
    ULARGE_INTEGER ulDueTime;
    UINT rollback = 0;

InitializeThreadpoolEnvironment(&CallBackEnviron);

    //
    // Create a custom, dedicated thread pool.
    //
    pool = CreateThreadpool(NULL);

    if (NULL == pool) {
        _tprintf(_T("CreateThreadpool failed. LastError: %u\n"),
            GetLastError());
        goto main_cleanup;
    }

rollback = 1; // pool creation succeeded

    //
    // The thread pool is made persistent simply by setting
    // both the minimum and maximum threads to 1.
    //
    SetThreadpoolThreadMaximum(pool, 1);

bRet = SetThreadpoolThreadMinimum(pool, 1);

    if (FALSE == bRet) {
        _tprintf(_T("SetThreadpoolThreadMinimum failed. LastError: %u\n"),
            GetLastError());
        goto main_cleanup;
    }

    //
    // Create a cleanup group for this thread pool.
    //
    cleanupgroup = CreateThreadpoolCleanupGroup();

    if (NULL == cleanupgroup) {
        _tprintf(_T("CreateThreadpoolCleanupGroup failed. LastError: %u\n"),
            GetLastError());
        goto main_cleanup;
    }

rollback = 2; // Cleanup group creation succeeded

    //
    // Associate the callback environment with our thread pool.
    //
    SetThreadpoolCallbackPool(&CallBackEnviron, pool);

    //
    // Associate the cleanup group with our thread pool.
    // Objects created with the same callback environment
    // as the cleanup group become members of the cleanup group.
    //
    SetThreadpoolCallbackCleanupGroup(&CallBackEnviron,
        cleanupgroup,
        NULL);

    //
    // Create work with the callback environment.
    //
    work = CreateThreadpoolWork(workcallback,
        NULL,
        &CallBackEnviron);

    if (NULL == work) {
        _tprintf(_T("CreateThreadpoolWork failed. LastError: %u\n"),
            GetLastError());
        goto main_cleanup;
    }

rollback = 3; // Creation of work succeeded

    //
    // Submit the work to the pool. Because this was a pre-allocated
    // work item (using CreateThreadpoolWork), it is guaranteed to execute.
    //
    SubmitThreadpoolWork(work);

    //
    // Create a timer with the same callback environment.
    //
    timer = CreateThreadpoolTimer(timercallback,
        NULL,
        &CallBackEnviron);

    if (NULL == timer) {
        _tprintf(_T("CreateThreadpoolTimer failed. LastError: %u\n"),
            GetLastError());
        goto main_cleanup;
    }

rollback = 4; // Timer creation succeeded

    //
    // Set the timer to fire in one second.
    //
    ulDueTime.QuadPart = (LONGLONG) -(1 * 10 * 1000 * 1000);
    FileDueTime.dwHighDateTime = ulDueTime.HighPart;
    FileDueTime.dwLowDateTime = ulDueTime.LowPart;

    SetThreadpoolTimer(timer,
        &FileDueTime,
        0,
        0);

    //
    // Delay for the timer to be fired
    //
    Sleep(1500);

    //
    // Wait for all callbacks to finish.
    // CloseThreadpoolCleanupGroupMembers also releases objects
    // that are members of the cleanup group, so it is not necessary
    // to call close functions on individual objects
    // after calling CloseThreadpoolCleanupGroupMembers.
    //
    CloseThreadpoolCleanupGroupMembers(cleanupgroup,
        FALSE,
        NULL);

    //
    // Already cleaned up the work item with the
    // CloseThreadpoolCleanupGroupMembers, so set rollback to 2.
    //
    rollback = 2;
    goto main_cleanup;

main_cleanup:
    //
    // Clean up any individual pieces manually
    // Notice the fall-through structure of the switch.
    // Clean up in reverse order.
    //

    switch (rollback) {
    case 4:
    case 3:
        // Clean up the cleanup group members.
        CloseThreadpoolCleanupGroupMembers(cleanupgroup,
            FALSE, NULL);
    case 2:
        // Clean up the cleanup group.
        CloseThreadpoolCleanupGroup(cleanupgroup);

    case 1:
        // Clean up the pool.
        CloseThreadpool(pool);

    default:
        break;
    }

return;
}

VOID
    DemoNewRegisterWait()
{
    PTP_WAIT Wait = NULL;
    PTP_WAIT_CALLBACK waitcallback = MyWaitCallback;
    HANDLE hEvent = NULL;
    UINT i = 0;
    UINT rollback = 0;

    //
    // Create an auto-reset event.
    //
    hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    if (NULL == hEvent) {
        // Error Handling
        return;
    }

rollback = 1; // CreateEvent succeeded

    Wait = CreateThreadpoolWait(waitcallback,
        NULL,
        NULL);

    if(NULL == Wait) {
        _tprintf(_T("CreateThreadpoolWait failed. LastError: %u\n"),
            GetLastError());
        goto new_wait_cleanup;
    }

rollback = 2; // CreateThreadpoolWait succeeded

    //
    // Need to re-register the event with the wait object
    // each time before signaling the event to trigger the wait callback.
    //
    for (i = 0; i < 5; i ++) {
        SetThreadpoolWait(Wait,
            hEvent,
            NULL);

SetEvent(hEvent);

        //
        // Delay for the waiter thread to act if necessary.
        //
        Sleep(500);

        //
        // Block here until the callback function is done executing.
        //

WaitForThreadpoolWaitCallbacks(Wait, FALSE);
}

new_wait_cleanup:
    switch (rollback) {
    case 2:
        // Unregister the wait by setting the event to NULL.
        SetThreadpoolWait(Wait, NULL, NULL);

// Close the wait.
CloseThreadpoolWait(Wait);

    case 1:
        // Close the event.
        CloseHandle(hEvent);

    default:
        break;
    }
    return;
}

int _tmain(int argc, _TCHAR* argv[])
{
    DemoNewRegisterWait();
    DemoCleanupPersistentWorkTimer();
    return 0;
}

本文链接

Win32控制台清屏方法

2010-06-30T12:18:00Z

最后觉得项目中的控制台不大好用，就添加了一些小功能，比如清屏；当然最简单的方法是调用系统自带的函数system(“cls”);，这里提供一个方法一样可以清屏（测试要比cls快一些）：

/* Standard error macro for reporting API errors */ 
 #define PERR(bSuccess, api){if(!(bSuccess)) printf("%s:Error %d from %s \ 
    on line %d\n", __FILE__, GetLastError(), api, __LINE__);}

 void cls( HANDLE hConsole )
 {
    COORD coordScreen = { 0, 0 };    /* here's where we'll home the
                                        cursor */ 
    BOOL bSuccess;
    DWORD cCharsWritten;
    CONSOLE_SCREEN_BUFFER_INFO csbi; /* to get buffer info */ 
    DWORD dwConSize;                 /* number of character cells in
                                        the current buffer */ 

    /* get the number of character cells in the current buffer */ 

    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
    PERR( bSuccess, "GetConsoleScreenBufferInfo" );
    dwConSize = csbi.dwSize.X * csbi.dwSize.Y;

    /* fill the entire screen with blanks */ 

    bSuccess = FillConsoleOutputCharacter( hConsole, (TCHAR) ' ',
       dwConSize, coordScreen, &cCharsWritten );
    PERR( bSuccess, "FillConsoleOutputCharacter" );

    /* get the current text attribute */ 

    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
    PERR( bSuccess, "ConsoleScreenBufferInfo" );

    /* now set the buffer's attributes accordingly */ 

    bSuccess = FillConsoleOutputAttribute( hConsole, csbi.wAttributes,
       dwConSize, coordScreen, &cCharsWritten );
    PERR( bSuccess, "FillConsoleOutputAttribute" );

    /* put the cursor at (0, 0) */ 

    bSuccess = SetConsoleCursorPosition( hConsole, coordScreen );
    PERR( bSuccess, "SetConsoleCursorPosition" );
    return;
 }

本文链接