4318人阅读
Python编程实例（13）
& &&&&& 使用python完成2048的代码编写。
&&&&&&& 2048游戏规则：简单的移动方向键让数字叠加，并且获得这些数字每次叠加后的得分，当出现2048这个数字时游戏胜利。同时每次移动方向键时，都会在这个4*4的方格矩阵的空白区域随机产生一个数字2或者4，如果方格被数字填满了，那么就GameOver了。
&&&&&&&& 实现思路：2048游戏的全部操作都是围绕着一个4*4的矩阵进行，每次从用户界面获取用户的操作（即移动方向），然后重新计算这个4*4矩阵的状态，最后刷新用户界面显示4*4矩阵的最新状态，不断的循环这个过程，直到出现2048或没有空白方块了，如下是一个处理流程示意图：
二、运行图
&&&&&& Python控制台程序，用字符（W/S/A/D）代表方向键的输入，以数字0代表空白方格。计算部分：以向左移动为例，4*4矩阵在接收到向左移动的指令后，应该将每行的数字向左叠加， 将一行的叠加操作定义为函数 handle(list, direction)，其第一个参数用来存储4*4矩阵中的某一行（列），第二个参数表示移动的方向（上下左右）。&这样当左右移动方向键时，可以这样来计算矩阵：遍历矩阵的每行，并将每行的数字沿左或右进行叠加操作，for row in matrix:handle(row, direction)。对于上下移动方向键时，由于矩阵是按行存储的，不能直接处理矩阵中的列，可以通过变通采用上面的函数handle()。对于矩阵中每一列，先将其拷贝到一个列表中，然后调用handle()函数对该列表进行叠加处理，最后再将叠加后的新列表拷贝回原始矩阵中其所在的列，其逻辑上等同于下面的代码操作。
for col in matrix:handle(col, direction)。
&&&&&& handle(row, direction)函数的作用是沿指定方向叠加一行中的数字，请看下面几个例子：
&&&&&&& 实现handle函数是关键。仔细观察叠加的过程，其都是由两个子过程组成的：
(1)&align(row, direction)沿direction方向对齐列表row中的数字，例如：
x = [0, 4, 0, 2]
align(x, 'left') &后 x = [4, 2, 0, 0]
在 align(x, 'right') 后 x = [0, 0, 4, 2]
(2)&addSame(row, direction)&查找相同且相邻的数字。如果找到，将其中一个翻倍，另一个置0（如果direction是'left'将左侧翻倍，右侧置0，如果direction为'right'，将右侧翻倍，左侧置0），并返回True；否则，返回False。例如：
x = [2, 2, 2, 2]
addSame(x, 'left') 后 x = [4, 0, 2, 2] & & &返回 True
再 addSame(x, 'left') 后 x = [4, 0, 4, 0] & 返回 True
再 addSame(x, 'left') 后 x = [4, 0, 4, 0] & 返回 False&
&&&&&& 有了上面两个子函数，应该不难实现。有了这两个子函数，函数handle()就很好实现了，如下：
handle(row, direction):
& & & & & align(row, direction)
& & & & & result = addSame(row, direction)
& & & & & while result == True:
& & & & & & & & & & align(row, direction)
& & & & & & & & & & result = addSame(row, direction)
& & &下面结合一个实际例子再来看看handle函数的处理过程：
x = [2, 4, 2, 2]
调用 handle(x, 'right')，变量 x 变化过程：
align(x, 'right') & & & && -& & &&[2, 4, 2, 2]
addSame(x, 'right') & -& & & [2, 4, 0, 4] & & -& & & return True
align(x, 'right') & &&&&&& -& & &&[0, 2, 4, 4] & &
addSame(x, 'right') & -& & & [0, 2, 0, 8] & & -& & & return True
align(x, 'right') & &&&&&& -& & &&[0, 0, 2, 8] & &
addSame(x, 'right') & -& & &&[0, 0, 2, 8]&& & -& & & return False
最终得到的 x = [0, 0, 2, 8]
（1）文件2048.py，运行：python 2048.py，运行环境linux python2.6.6。
# -*- coding:UTF-8 -*-
#! /usr/bin/python
import random
import sys
v = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0] ]
def display(v, score):
'''显示界面
'''
print '{0:4} {1:4} {2:4} {3:4}'.format(v[0][0], v[0][1], v[0][2], v[0][3])
print '{0:4} {1:4} {2:4} {3:4}'.format(v[1][0], v[1][1], v[1][2], v[1][3])
print '{0:4} {1:4} {2:4} {3:4}'.format(v[2][0], v[2][1], v[2][2], v[2][3])
print '{0:4} {1:4} {2:4} {3:4}'.format(v[3][0], v[3][1], v[3][2], v[3][3]), '
Total score: ', score
def init(v):
'''随机分布网格值
'''
for i in range(4):
v[i] = [random.choice([0, 0, 0, 2, 2, 4]) for x in v[i]]
def align(vList, direction):
'''对齐非零的数字
direction == 'left'：向左对齐，例如[8,0,0,2]左对齐后[8,2,0,0]
direction == 'right'：向右对齐，例如[8,0,0,2]右对齐后[0,0,8,2]
'''
# 移除列表中的0
for i in range(vList.count(0)):
vList.remove(0)
# 被移除的0
zeros = [0 for x in range(4 - len(vList))]
# 在非0数字的一侧补充0
if direction == 'left':
vList.extend(zeros)
vList[:0] = zeros
def addSame(vList, direction):
'''在列表查找相同且相邻的数字相加, 找到符合条件的返回True，否则返回False,同时还返回增加的分数
direction == 'left':从右向左查找，找到相同且相邻的两个数字，左侧数字翻倍，右侧数字置0
direction == 'right':从左向右查找，找到相同且相邻的两个数字，右侧数字翻倍，左侧数字置0
'''
if direction == 'left':
for i in [0, 1, 2]:
if vList[i] == vList[i+1] != 0:
vList[i] *= 2
vList[i+1] = 0
score += vList[i]
return {'bool':True, 'score':score}
for i in [3, 2, 1]:
if vList[i] == vList[i-1] != 0:
vList[i-1] *= 2
vList[i] = 0
score += vList[i-1]
return {'bool':True, 'score':score}
return {'bool':False, 'score':score}
def handle(vList, direction):
'''处理一行（列）中的数据，得到最终的该行（列）的数字状态值, 返回得分
vList: 列表结构，存储了一行（列）中的数据
direction: 移动方向,向上和向左都使用方向'left'，向右和向下都使用'right'
'''
totalScore = 0
align(vList, direction)
result = addSame(vList, direction)
while result['bool'] == True:
totalScore += result['score']
align(vList, direction)
result = addSame(vList, direction)
return totalScore
def operation(v):
'''根据移动方向重新计算矩阵状态值，并记录得分
'''
totalScore = 0
gameOver = False
direction = 'left'
op = raw_input('operator:')
if op in ['a', 'A']:
# 向左移动
direction = 'left'
for row in range(4):
totalScore += handle(v[row], direction)
elif op in ['d', 'D']:
# 向右移动
direction = 'right'
for row in range(4):
totalScore += handle(v[row], direction)
elif op in ['w', 'W']:
# 向上移动
direction = 'left'
for col in range(4):
# 将矩阵中一列复制到一个列表中然后处理
vList = [v[row][col] for row in range(4)]
totalScore += handle(vList, direction)
# 从处理后的列表中的数字覆盖原来矩阵中的值
for row in range(4):
v[row][col] = vList[row]
elif op in ['s', 'S']:
# 向下移动
direction = 'right'
for col in range(4):
vList = [v[row][col] for row in range(4)]
totalScore += handle(vList, direction)
for row in range(4):
v[row][col] = vList[row]
print('Invalid input, please enter a charactor in [W, S, A, D] or the lower')
return {'gameOver':gameOver, 'score':totalScore}
# 统计空白区域数目 N
for q in v:
N += q.count(0)
# 不存在剩余的空白区域时，游戏结束
if N == 0:
gameOver = True
return {'gameOver':gameOver, 'score':totalScore}
# 按2和4出现的几率为3/1来产生随机数2和4
num = random.choice([2, 2, 2, 4])
# 产生随机数k，上一步产生的2或4将被填到第k个空白区域
k = random.randrange(1, N+1)
for i in range(4):
for j in range(4):
if v[i][j] == 0:
if n == k:
v[i][j] = num
return {'gameOver':gameOver, 'score':totalScore}
print 'Input：W(Up) S(Down) A(Left) D(Right), press &CR&.'
while True:
display(v, score)
result = operation(v)
if result['gameOver'] == True:
print 'Game Over, You failed!'
print 'Your total score:', score
sys.exit(1)
score += result['score']
if score &= 2048:
print 'Game Over, You Win!!!'
print 'Your total score:', score
sys.exit(0)
（2）修改出现例如（4，4，8，0）这样的情况，得分不合理的情况
# -*- coding:UTF-8 -*-
#!/usr/bin/python2
import random
import os, sys
v = [[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
def display(v, score):
print &%4d %4d %4d %4d& % (v[0][0], v[0][1], v[0][2], v[0][3])
print &%4d %4d %4d %4d& % (v[1][0], v[1][1], v[1][2], v[1][3])
print &%4d %4d %4d %4d& % (v[2][0], v[2][1], v[2][2], v[2][3])
print &%4d %4d %4d %4d& % (v[3][0], v[3][1], v[3][2], v[3][3])
print &Total score: %d& % score
def init(v):
for i in range(4):
v[i] = [random.choice([0, 0, 0, 2, 2, 4]) for x in range(4)]
def align(vList, direction):
for i in range(vList.count(0)):
vList.remove(0)
zeros = [0 for x in range(4 - len(vList))]
if direction == 'left':
vList.extend(zeros)
vList[:0] = zeros
def addSame(vList, direction):
if direction == 'left':
for i in [0, 1, 2]:
align(vList, direction)
if vList[i] == vList[i+1] != 0:
vList[i] *= 2
vList[i+1] = 0
score += vList[i]
return {'bool':True, 'score':score}
for i in [3, 2, 1]:
align(vList, direction)
if vList[i] == vList[i-1] != 0:
vList[i] *= 2
vList[i-1] = 0
score += vList[i]
return {'bool':True, 'score':score}
return {'bool':False, 'score':score}
def handle(vList, direction):
totalScore = 0
align(vList, direction)
result = addSame(vList, direction)
while result['bool'] == True:
totalScore += result['score']
align(vList, direction)
result = addSame(vList, direction)
return totalScore
def operation(v):
totalScore = 0
gameOver = False
direction = 'left'
op = raw_input('operator:')
if op in ['a','A']:
direction = 'left'
for row in range(4):
totalScore += handle(v[row], direction)
elif op in ['d','D']:
direction = 'right'
for row in range(4):
totalScore += handle(v[row], direction)
elif op in ['w', 'W']:
direction = 'left'
for col in range(4):
vList = [v[row][col] for row in range(4)]
totalScore += handle(vList, direction)
for row in range(4):
v[row][col] = vList[row]
elif op in ['s', 'S']:
direction = 'right'
for col in range(4):
vList = [v[row][col] for row in range(4)]
totalScore += handle(vList, direction)
for row in range(4):
v[row][col] = vList[row]
print &Invalid input,please enter a charactor in [W,S,A,D] or the lower&
gameOver = True
return {'gameOver':gameOver,'score':totalScore}
for q in v:
N += q.count(0)
if N == 0:
gameOver = True
return {'gameover':gameOver,'score':totalScore}
num = random.choice([2,2,2,4])
k = random.randrange(1, N+1)
for i in range(4):
for j in range(4):
if v[i][j] == 0:
if n == k:
v[i][j] = num
return {'gameOver':gameOver, 'score':totalScore}
print &Input：W(Up) S(Down) A(Left) D(Right), press &CR&.&
while True:
os.system(&clear&)
display(v, score)
result = operation(v)
print result
if result['gameOver'] == True:
print &Game Over, You failed!&
print &Your total score %d& % (score)
sys.exit(1)
score += result['score']
if score &= 2048:
print &Game Over, You Win!!!&
print &Your total score: %d& % (score)
sys.exit(0)（3）linux使用ncurses库实现的2048&ai
/***********************************
*makefile:
*CFLAGS=-g -O3 -lncurses
*.PHONY : all
*all: 2048.c
$(CC) 2048.c -o 2048 $(CFLAGS)
************************************
*---Play----
&-- Normal mode
* ./2048 -s
&-- Play with AI suggestion
* ./2048 -a
&-- Watch AI plays it. Good luck!
************************************/
#include &unistd.h&
#include &stdio.h&
#include &stdlib.h&
#include &ncurses.h&
#include &sys/time.h&
#include &time.h&
#define AUTO
#define SIZE (4)
typedef int board_t[SIZE][SIZE];
struct hash_elem {
enum input {
RIGHT = 1,
/* Static mappings & initialzation ***********************************/
/* Weight of each value */
int value_weight[16];
/* Mapping from value to power of 2 form */
int value_real[16];
/* Default search depth for each #zero-blocks */
int depth_map[] = {6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4};
/* Weight map of cells */
static const board_t cell_weight = {
{17, 13, 11, 10},
/* Used for hash table */
static const board_t primes = {
{, 115249}
void init() {
int cur_weight = 1;
int cur_real = 2;
for (i = 1; i & 16; i++) {
value_weight[i] = cur_
value_real[i] = cur_
cur_weight *= 3;
cur_real *= 2;
/* Util Functions *****************************************************/
long gettime() {
gettimeofday(&tv, NULL);
return tv.tv_sec * 1000 * 1000 + tv.tv_
void draw_grid(int y, int x) {
mvprintw(y++, x,
&#####################################&);
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
&#-----------------------------------#&);
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
&#-----------------------------------#&);
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
&#-----------------------------------#&);
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
mvprintw(y++, x,
&#####################################&);
mvprintw(y+2, x,
&Control: wasd
Exit: q&);
void board_dump(board_t b, int y, int x) {
draw_grid(y, x);
for (i = 0; i & SIZE; i++) {
for (j = 0; j & SIZE; j++) {
if (b[i][j])
mvprintw(i * 4 + 2 + y, j * 9 + 3 + x, &%d&, value_real[b[i][j]]);
int board_count_zero(board_t b) {
int cnt = 0;
for (i = 0; i & SIZE; i++) {
for (j = 0; j & SIZE; j++) {
if (b[i][j] == 0)
void board_clear(board_t b) {
for (i = 0; i & SIZE; i++) {
for (j = 0; j & SIZE; j++) {
b[i][j] = 0;
int board_hash(board_t b) {
int hash = 0;
for (i = 0; i & SIZE; i++) {
for (j = 0; j & SIZE; j++) {
hash += b[i][j] * primes[i][j];
void board_rnd_gen_cell(board_t b) {
int cnt = board_count_zero(b);
int gen = random() %
int n = (random() % 10) == 0 ? 2 : 1;
for (i = 0; i & SIZE; i++) {
for (j = 0; j & SIZE; j++) {
if (b[i][j] == 0) {
if (cnt == gen) {
void delay() {
t.tv_sec = 0;
t.tv_nsec = ;
nanosleep(&t, NULL);
/* Performance statistic */
long stat_time[16];
long stat_count[16];
void stat(int depth, long time) {
stat_count[depth]++;
stat_time[depth] +=
void stat_dump() {
int line = 0;
mvprintw(25 + line++, 8, &Performance Stat&);
for (i = 0; i & 16; i++) {
if (!stat_count[i])
mvprintw(25 + line++, 8, &[Depth %d] %ld us * %d times&,
i, stat_time[i] / stat_count[i], stat_count[i]);
/* Game logic: Move to a direction **************************************************/
/* Return score earned, return 1 if moved with zero score */
#define movefunc(src_cell, combine_cell, nocombine_cell)\
int i, j = 0;\
int moved = 0;\
int score = 0;\
for (i = 0; i & SIZE; i++) {\
int last = 0;\
int j2 = 0;\
for (j = 0; j & SIZE; j++) {\
int v = src_\
if (v == 0) {\
if (v == last) {\
last = 0;\
combine_cell = v + 1;\
score += value_real[v + 1];\
if (j2 & j)\
moved = 1;\
nocombine_cell =\
return score ? score :\
#define REVERSE(i) (SIZE - 1 - (i))
int move_left(board_t src, board_t dst) {
movefunc(src[i][j], dst[i][j2 - 1], dst[i][j2]);
int move_right(board_t src, board_t dst) {
movefunc(src[i][REVERSE(j)], dst[i][REVERSE(j2 - 1)], dst[i][REVERSE(j2)]);
int move_up(board_t src, board_t dst) {
movefunc(src[j][i], dst[j2 - 1][i], dst[j2][i]);
int move_down(board_t src, board_t dst) {
movefunc(src[REVERSE(j)][i], dst[REVERSE(j2 - 1)][i], dst[REVERSE(j2)][i]);
/* AI-related functions **************************************************/
double value(board_t b, int depth, int *choice, double max);
/* Immediate value score estimation for a board */
int imm_value(board_t b) {
int result = 0;
for (i = 0; i & SIZE; i++) {
for (j = 0; j & SIZE; j++) {
result += value_weight[b[i][j]] * cell_weight[i][j];
#define HASH_SIZE (35317)
struct hash_elem vcache[HASH_SIZE];
void cache_board_value(board_t b, int depth, double value) {
int hash = board_hash(b);
int index = hash % HASH_SIZE;
vcache[index].hash =
vcache[index].value =
vcache[index].depth =
double query_board_value(board_t b, int depth) {
int hash = board_hash(b);
int index = hash % HASH_SIZE;
if (vcache[index].hash == hash && vcache[index].depth &= depth) {
return vcache[index].
return -1;
/* Generate 2/4 at every posible position, return the average value score
: the board
: depth of the recursive search
: current maximum value score
: sample rate, 0 means no sample
double rnd_value(board_t b, int depth, double max, int sampled) {
int cnt = 0;
double sum = 0;
static int scnt = 0;
for (i = 0; i & SIZE; i++) {
for (j = 0; j & SIZE; j++) {
/* Check zero */
if (b[i][j])
/* Do sampling to reduce computation if needed */
if (sampled) {
if(scnt % sampled)
b[i][j] = 1;
sum += 9 * value(b, depth, NULL, max);
/* We do not take random 4 into consideration as it is rare */
if (depth &= 5) {
b[i][j] = 2;
sum += value(b, depth, NULL, max);
b[i][j] = 0;
return sum /
/* Return the value score for given board, zero score means died
: the board
: depth of the recursive search
: used to return the final choise of movement
: current maximum value score
double value(board_t b, int depth, int *choice, double max) {
/* Estimate the value score */
int estimate = imm_value(b);
/* Decrease depth if estimation is too low */
if (estimate & max * 0.7)
/* Return estimation at level 0 */
if (depth &= 0)
/* Adjust next depth according to depth_map */
int next_depth = depth - 1;
if (depth & 3) {
int zeros = board_count_zero(b);
if (next_depth & depth_map[zeros])
next_depth--;
int moved[4];
double maxv = 0;
board_t tmp[4] = {0};
int my_choice = QUIT; /* Default choice */
if (!choice) {
double v = query_board_value(b, depth);
if (v &= 0)
moved[LEFT] = move_left(b, tmp[LEFT]);
moved[RIGHT] = move_right(b, tmp[RIGHT]);
moved[UP] = move_up(b, tmp[UP]);
moved[DOWN] = move_down(b, tmp[DOWN]);
/* Estimate the maximum value score */
if (depth & 2)
for (i = 0; i & 4; i++) {
int v = imm_value(tmp[0]);
max = v & max ? v :
/* Try all the four direction */
for (i = 0; i & 4; i++) {
if (!moved[i])
int sample = 0; //depth & 3 ? 3 : 1;
double v = rnd_value(tmp[i], next_depth, max, sample);
if (v & maxv) {
my_choice =
if (choice)
*choice = my_
cache_board_value(b, depth, maxv);
/* Game logic: Control and Interface *************************************/
static int get_AI_input(board_t b) {
int zeros = board_count_zero(b);
long start = gettime();
double v = value(b, depth_map[zeros], &choice, 0);
long timeval = gettime() -
stat(depth_map[zeros], timeval);
static int get_keyboard_input() {
while(1) {
//c = getchar();
c = getch();
switch(c) {
case 'w': return UP;
case 'a': return LEFT;
case 's': return DOWN;
case 'd': return RIGHT;
case 'q': return QUIT;
int auto_play = 0;
int suggestion = 0;
void game_loop() {
board_t a = {0};
board_t b = {0};
int score = 0;
next = &b;
board_rnd_gen_cell(*cur);
while (1) {
/* Draw the board */
board_dump(*cur, 4, 8);
// stat_dump();
/* AI computation */
if (auto_play || suggestion) {
AI_input = get_AI_input(*cur);
const char *move_text[] = {&Left&, &Right&, &Up&, &Down&, &Game Over&};
mvprintw(1, 8, &Suggest: %s&, move_text[AI_input]);
mvprintw(2, 8, &Score: %d&, score);
/* Update screen */
refresh();
/* Get input */
if (auto_play) {
input = AI_
input = get_keyboard_input();
int moved = 0;
switch(input) {
moved = move_up(*cur, *next);
case LEFT:
moved = move_left(*cur, *next);
case DOWN:
moved = move_down(*cur, *next);
case RIGHT:
moved = move_right(*cur, *next);
case QUIT:
if (!moved)
if (moved != 1)
/* Generate new cell */
board_rnd_gen_cell(*next);
/* Switch cur and next */
board_t *temp =
board_clear(*next);
int main(int argc, char *argv[]) {
while ((opt = getopt(argc, argv, &as&)) != -1) {
switch (opt) {
case 'a':
auto_play = 1;
case 's':
suggestion = 1;
default: /* '?' */
fprintf(stderr, &Usage: %s [-a] [-s]\r\n&, argv[0]);
fprintf(stderr, &-a:
Let AI play the game\r\n&);
fprintf(stderr, &-s:
Display AI suggestion\r\n&);
exit(EXIT_FAILURE);
srandom(time(NULL));
initscr();
game_loop();
refresh();
编译：gcc -g -O3 -o .c -lncurses
运行：（第一图是正常模式，第二图是提示模式，第三张图是人工智能模式）
（1）代码皆是总结而至，具体细节还待以后深入研究。
（2）代码中有比较多的问题，有待完善的地方还很多。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：900680次
积分：10477
积分：10477
排名：第1256名
原创：272篇
转载：98篇
评论：246条
(1)(1)(1)(1)(1)(5)(4)(6)(6)(8)(10)(20)(9)(13)(11)(13)(7)(9)(17)(19)(21)(87)(17)(10)(20)(11)(8)(6)(16)(1)(1)【已回复】谁说Java不能开发大型游戏， 本人Java写的传奇, 有视频真相
网游， 非单机版。
客户端和服务器都是纯Java版的.
画面流畅程度完胜盛大的原版， 跑一步地图卷动48次，是电影级的。细节不多说了
发这个帖子的主要目的是说明：
&&&&&&&&用Java可以做任何游戏， Java速度慢什么的都是扯淡...我这程序已经和游资网上N个C++达人的同类产品比较过了， 性能完胜。 (所以就算C++快，也需要写程序的人优化的好才行)
视频只是演示了几分钟道士操作。虽然只有我一个用户在线，但是对于服务器而言， 还控制了12000+个怪物的智能行为, 姑且算是很多人在线了。(当然， 怪物和用户还是不相同的)。
Ps: 视频不够流畅，是我的录像软件FPS太低造成的， 游戏本身比这个要强的多.
下面是截图:
首先，要说lz真的很牛。
另外，关于java适合不适合开发大型游戏的问题，我觉得最大的障碍是用java开发的客户端总是要先启动jvm，这个会影响游戏的启动速度，体验不好。
至于没有使用java开发的游戏这一现象，我到觉得还有一个很重要的原因，就是游戏行业是一个非常保守的行业，会尽量使用原来已经稳定的代码，而老的代码，基本都是c++的吧，除非有非常强烈的理由，否则是不会轻易换的。
如果Minecraft还不具说服力,那就再看看一个Web-based Java Applet游戏平台RuneScape,同样是一个极其成功的案例:
《RuneScape》是由英国Jagex采用Java开发的基于网页的大型多人在线角色扮演游戏，在世界上很受欢迎，尤其是英国及美国。
引用来自“eechen”的答案引用来自“擅长被美女推倒”的答案引用来自“eechen”的答案引用来自“擅长被美女推倒”的答案
引用来自“eechen”的答案
引用来自“擅长被美女推倒”的答案
做东西要以赚钱为目的，用java做大型游戏很难卖出好价钱，因为这根本不会有老板投资做商业化运营，就算做出来 也就自己无聊玩玩，这纯粹浪费时间，php还能做桌面呢，但是做出来东西要有人要么，能赚钱么，做什么就用什么工具，做游戏就用C++，做web你可以用java/php，非要用java做大型游戏，只是无聊自己玩而已，
相信游戏控都知道有那么一个Java Platform的3D游戏&我的世界&Minecraft,GameSpy给予五星满分评价,绝对的热门游戏!
Minecraft不赚钱,别秀逗了,横跨PC/Mac/Linux/Android/iOS/Xbox平台,不赚钱,你去开发?
http://zh.wikipedia.org/wiki/Minecraft
Minecraft使用了引擎Lightweight Java Game Library(LWJGL),
LWJGL包含了对OpenGL的封装,引擎自身使用Java和C开发,采用宽松的BSD授权.
http://en.wikipedia.org/wiki/Lightweight_Java_Game_Library
你怎么拿PHP做桌面跟Java做游戏比,我觉得拿Python做桌面跟Java做游戏可能还比较恰当. 事实上用Java做游戏服务器端逻辑多的是,做游戏客户端的确实比C++少,但不代表不能做.
最后,支持楼主!
java做大型游戏不赚钱，不是说说的，这是事实，国内大型游戏公司，自己去做调查，你投资过游戏运营不，你敢拿一款大型JAVA游戏投资看看，亏不死你，这些东西不能看网上吹的，很简单你直接去找你老板问他敢不敢投资就行了，我们投资成功的大型游戏还真没见过java做的，至于java做页游或手机游戏，这能赚到点钱是真的，你拿着2个java例子，去多找个C++的例子比下，最多算半成品而已，
我只举了1个例子,使用引擎LWJGL的游戏Minecraft,不是2个,而且这个游戏相比C++游戏也绝非你想象中的半成品,没玩过就不要乱说了,另外有一个使用Irrlicht引擎和C++写的开源游戏Minetest,很像Minecraft,你看有谁玩?
说实话敢发这样的帖子的也就是java程序员，既没开发过大型游戏，也没运营过大型游戏就敢发这样的帖子，俺还真佩服，所谓无知者无畏，也不怕业内的兄弟笑话，赚不赚钱，俺已经说过了，不要看网上吹的，就去找你老板问他敢不敢运营，再多的话，上头有个兄弟，估计是业内的，俺就直接复制了，不打字了，
楼主，你的水平很好，只是你走错了路子。如果你的视野更开阔一点，不要眼里只有Java，你肯定能走的更远。
先说适用范围，用Java写不是不可以，只是只能用来写上层逻辑。你这个2D的，只有纹理贴图，在商业级的产品里，真的只是一些上层逻辑，用任何语言都可以做，用Java来做，只是一个蹩脚的选择而已。客户端如果需要做出一点效果来，比如 Particle ，或者 Shadow，用纯Java是无法胜任的。如果硬要用Java来做，也只能是用C来写关键部分，然后bind一个Java的JNI来写。例子就是android上的游戏，Java只是一个wrapper，关键的东西还是C/C++。
再说灵活性，做一般的服务器需求，有丰富的库和框架，Java还可以胜任。但是如果要商业级，产品级的游戏，Java写起来又显得太罗嗦，到时候JAVA的开发周期会比C++短吗，这个是一个仁者见仁的问题。如果你有大量的东西需要策划去做，你还觉得Java是一个可行的方案么？脚本策划会写JAVA代码吗，不会。但是脚本策划会写Lua代码。
最后再说性能，就拿web服务器来说，nginx + Lua 和 Apache。 谁性能高，不多说了吧，虽然普通的web服务 Apache足以。参考TEngine和OpenResty。
最后，在实际项目里。可能拿JAVA一门语言和 C + Lua 两门语言一起比，不太公平。但是，C + Lua两门语言的学习成本有JAVA高吗？主程写底层C，新人写Lua。为了达到灵活的需求，Java那些厚重的抽象层，和简单的脚本比起来。不比了，比多了都是泪。
上面提到的MC, MC无疑非常成功，Java功不可没。但是持续关注MC，你会发现，新版本的MC xbox360 (XNA C# + C++ ) 。 MCPE （Android C++, IOS OOC)，你有再看到Java的身影么？ 为什么后续版本没有继续选择Java？ IOS 不支持Java就算了， Android呢？Java可是Android开发的首选语言 ？为什么MC不选择Java呢？
PS:我也够无聊的了，这是第一次参加语言论战。
想起两个个笑话。老梗了。
一个女神和一个程序员在一起，女神说：“你要是让一群程序员吵得不可开交的话，今晚我就和你走。”程序员说了一句python是世界上最好的语言，接下来就吵起来了，等到之后大家吵得不可开交的时候女神告诉程序员，今晚上我是你的了。程序员说道：“你回去吧！，我必须说服他们Python是世界上最好的语言”。
一群男程序员酒后乱逛，正要集体侵犯一个女子。女子见势不妙，问：那你们说最好的 文本编辑器是哪个？程序员们就地讨论了三天三夜不欢而散，女子趁机顺利脱身
虽然Minecraft跨平台,但是GameSpy是以PC游戏给了Minecraft五颗星,正是在PC上火了,才会考虑迁移到移动平台.为了性能,Android上用C++完全合理.Minecraft支持Python Script,同样可以扩展.
还有这不是语言之争的问题,这是Java能不能用来开发游戏的问题,如果有人说Java不能开发赚钱的游戏,不能写游戏服务器端逻辑,我想就算是一个不玩Java的人也不会同意. 好吧，你也很无聊，来看评论。 - -#。
Java当然写的产品当然能赚钱，只不过是看这个钱赚的舒不舒服了。对一个程序员而言，能轻松的赚到钱（维护成本低，扩展型好，当然这个东西是和设计有关和语言无关的）才能算舒服吧。
我的观点是，Java没有成熟的服务端解决方案(框架)，也就意味着你需要做更多的基础工作，当然大牛用什么都无所谓。反观其他语言，比如C++有出名的ACE。连JS都有一个Pomelo（基于Node.js)。 Java呢，鄙人孤陋寡闻，没听说过。
还有一位同学提到，游戏开发是相对保守的。其实游戏行业不是保守，是因为做的东西都很稳定了，没有必要去频繁更新。用一些旧的但是稳定的技术，不能算保守。反而很多游戏开发人员是勇于尝试探索的，比如 Erlang在游戏服务端领域貌似受到重视了？
PS： 上大学的时候，用了1周，写过android应用，那时android最新版本才1.5（http://download.csdn.net/detail/ysleepers/2537506），接触过Java，开发效率真的没话说。不过从那之后就很反感Java，没什么特别的原因，就是 函数名字太长了。读着累。
--- 共有 7 条评论 ---
据我所知 GAEA的仙剑手游 后端就是java写的 当然前端妥妥u3d
你搜下蓝月传奇,传奇盛世试试,看你脸疼不疼.我是这公司的JAVA服务端
你们在逗我吗？java函数名长？你没看OC的函数名？
我太特么佩服我自己了 我把你们的对话看完了！
java不适合做服务端? 那java做客户端更难了.看过java语法,可以举例说下应用场景吗?
Java不适合开发大型游戏个人认为最大的弊端一个是Runtime library,比较臃肿,且天朝windows用户估计装机量比.net framewrok要少,二是jit的特性,跨平台对于游戏开发来说没有一点好处,反而背负了跨平台的缺陷(ByteCode).最后一点是GC,大型游戏对于资源和内存的控制都是细致入微,C++都要特意写自己的内存分配器和自己的资源管理策略.我不知道Java的GC做得如何,但是GC发生时间一般无法预知,在渲染时发生GC从而发生卡顿现象我想玩家都不愿意接受.小品级别的游戏除外.另外传奇是用Delphi写的,官方/私服也大都是Delphi,很少有人改成C++,一是工作量,二是Delphi写游戏要比Java更适合,效率也很高.所以先入为主也很重要.
还有很重要的一点是Java相对C++来说好反编译的多,否则估计楼主就直接放jar了而不是视频展示了,做出的游戏不能很好的保护源码对于Java来说也很头疼.
& @&我做了2年的客户端，刚开始学一些server的基本的东西。有一个简单的做游戏服务器的想法，看起来很傻，你们帮参考下可行不，先谢过。 & 我想，既然像nginx+Lua这样的web server可以处理超高的并发量。为什么游戏的服务端不能直接使用这些作为底层框架呢。？ 比如nginx+Lua的方案，通过nginx提供的share memory 存玩家的状态，然后玩家的行为直接用Lua脚本来写。
--- 共有 2 条评论 ---
像 我是Mt 那样的手游，通过良好的设计，好像没有要求长连接。另外二进制数据结构完全可以直接使用google protocol buffer这样封装一下成rpc。如果不是wow那样重量级的端游，手游可行吗？
支持大并发量是游戏服务器的一个基本要求,当然还要合理的设计和布局演变成集群架构,保持TCP长连接,处理私有协议二进制数据包等等.Web Server除了并发量外没有和游戏服务器太多的交集,除了外围的服务,核心架构基本都是要靠自己实现的.可以看看BigWorld的实现方案,据说是世界一流的MMORPG服务端实现方案.
楼上有没有怀疑过3000帧是有问题的，即便你测是看到的就是3000帧
，假如一个 这么大的平面， 需要的色彩大约是4M (RGBA) , 不考虑其他因素，
4M&3000= 12G，(内存到显存的速度能达到12G每秒????) 还不说有很多地方重复贴图，也就是说C++能够在1秒内在内存生成
12G数据， 并且传递给显存， 还要将它画出来。&
难道真没问题吗？ 还有你的方法能看到内存到显存的数据交换？这3000帧难道不可能是因为你重复贴图，对方发现你你干的同一件事情，根本没真的工作？
还有 电影只有25帧就很流畅了，人眼超过“120”帧， 帧越高效果越烂。
你们都说你们写的C++有多快，我这台机器， 市面上的C++，3D游戏基本跑不起来， 巨卡。
真感觉不到快。
--- 共有 9 条评论 ---
如果帧数抛却刻意锁屏,因为服务端计算,网络延迟,本机集显等等因素造成这点FPS,那只能说客观因素或者资源没有调配好.但渲染256色画面,一个背景+几个人物在现在的一般机器用软渲染都能达到100FPS.LZ的的确偏低了.既然LZ是要证明Java写游戏不比C++差,那么原谅我在FPS上啰嗦了.
: 这里只假设单机,没有考虑服务器等情况,也假设显存512M,1000人同屏只是渲染测试(很多是重叠)并没有太大实际用途.另外帧数所的3000FPS的确是计算有误,因为我的引擎默认是开启vSync,所以计算帧数是以平均渲染一帧的时间除以时间得到,再低帧数状态下越准确,再渲染能力多余的状态下就误差很大.实际不锁屏测试基本上有1000FPS.
打了很多错别字。
1000人互殴网游假设中：
假如每人每秒发起1次攻击， 需要服务器 "每秒"100万通信， 不是每天.
当然， 第2点是假设网游， 而你是假设单机， 我在这里可以期待你的 Exe。
对于我之前的假设， 你可以去查下， CPU到内存每秒最多交互多少数据， 内存到内存， 内存到显存。
还有， 我并没有对你的1000帧否定，这是有可能的， 只是需要看看EXE。
1:这游戏一个屏幕内只能容纳不到400人， 那么1000人如何互殴
2:如果网游， 1屏幕内如果有1000人互殴，每个人的动作，掉血等等就需要其他人看到， 假设每秒钟通行1次, 那么1000人每个都将数据发送给服务器， 服务器会广播给其他的1000人（999人）,
那么需要服务器 每天 完成 100次消息发送。
换句话讲，传说中的TPS 1000万！！！这是单台服务器。
引用来自“Tangsleepers”的答案引用来自“eechen”的答案引用来自“擅长被美女推倒”的答案引用来自“eechen”的答案引用来自“擅长被美女推倒”的答案
引用来自“eechen”的答案
引用来自“擅长被美女推倒”的答案
做东西要以赚钱为目的，用java做大型游戏很难卖出好价钱，因为这根本不会有老板投资做商业化运营，就算做出来 也就自己无聊玩玩，这纯粹浪费时间，php还能做桌面呢，但是做出来东西要有人要么，能赚钱么，做什么就用什么工具，做游戏就用C++，做web你可以用java/php，非要用java做大型游戏，只是无聊自己玩而已，
相信游戏控都知道有那么一个Java Platform的3D游戏&我的世界&Minecraft,GameSpy给予五星满分评价,绝对的热门游戏!
Minecraft不赚钱,别秀逗了,横跨PC/Mac/Linux/Android/iOS/Xbox平台,不赚钱,你去开发?
http://zh.wikipedia.org/wiki/Minecraft
Minecraft使用了引擎Lightweight Java Game Library(LWJGL),
LWJGL包含了对OpenGL的封装,引擎自身使用Java和C开发,采用宽松的BSD授权.
http://en.wikipedia.org/wiki/Lightweight_Java_Game_Library
你怎么拿PHP做桌面跟Java做游戏比,我觉得拿Python做桌面跟Java做游戏可能还比较恰当. 事实上用Java做游戏服务器端逻辑多的是,做游戏客户端的确实比C++少,但不代表不能做.
最后,支持楼主!
java做大型游戏不赚钱，不是说说的，这是事实，国内大型游戏公司，自己去做调查，你投资过游戏运营不，你敢拿一款大型JAVA游戏投资看看，亏不死你，这些东西不能看网上吹的，很简单你直接去找你老板问他敢不敢投资就行了，我们投资成功的大型游戏还真没见过java做的，至于java做页游或手机游戏，这能赚到点钱是真的，你拿着2个java例子，去多找个C++的例子比下，最多算半成品而已，
我只举了1个例子,使用引擎LWJGL的游戏Minecraft,不是2个,而且这个游戏相比C++游戏也绝非你想象中的半成品,没玩过就不要乱说了,另外有一个使用Irrlicht引擎和C++写的开源游戏Minetest,很像Minecraft,你看有谁玩?
说实话敢发这样的帖子的也就是java程序员，既没开发过大型游戏，也没运营过大型游戏就敢发这样的帖子，俺还真佩服，所谓无知者无畏，也不怕业内的兄弟笑话，赚不赚钱，俺已经说过了，不要看网上吹的，就去找你老板问他敢不敢运营，再多的话，上头有个兄弟，估计是业内的，俺就直接复制了，不打字了，
楼主，你的水平很好，只是你走错了路子。如果你的视野更开阔一点，不要眼里只有Java，你肯定能走的更远。
先说适用范围，用Java写不是不可以，只是只能用来写上层逻辑。你这个2D的，只有纹理贴图，在商业级的产品里，真的只是一些上层逻辑，用任何语言都可以做，用Java来做，只是一个蹩脚的选择而已。客户端如果需要做出一点效果来，比如 Particle ，或者 Shadow，用纯Java是无法胜任的。如果硬要用Java来做，也只能是用C来写关键部分，然后bind一个Java的JNI来写。例子就是android上的游戏，Java只是一个wrapper，关键的东西还是C/C++。
再说灵活性，做一般的服务器需求，有丰富的库和框架，Java还可以胜任。但是如果要商业级，产品级的游戏，Java写起来又显得太罗嗦，到时候JAVA的开发周期会比C++短吗，这个是一个仁者见仁的问题。如果你有大量的东西需要策划去做，你还觉得Java是一个可行的方案么？脚本策划会写JAVA代码吗，不会。但是脚本策划会写Lua代码。
最后再说性能，就拿web服务器来说，nginx + Lua 和 Apache。 谁性能高，不多说了吧，虽然普通的web服务 Apache足以。参考TEngine和OpenResty。
最后，在实际项目里。可能拿JAVA一门语言和 C + Lua 两门语言一起比，不太公平。但是，C + Lua两门语言的学习成本有JAVA高吗？主程写底层C，新人写Lua。为了达到灵活的需求，Java那些厚重的抽象层，和简单的脚本比起来。不比了，比多了都是泪。
上面提到的MC, MC无疑非常成功，Java功不可没。但是持续关注MC，你会发现，新版本的MC xbox360 (XNA C# + C++ ) 。 MCPE （Android C++, IOS OOC)，你有再看到Java的身影么？ 为什么后续版本没有继续选择Java？ IOS 不支持Java就算了， Android呢？Java可是Android开发的首选语言 ？为什么MC不选择Java呢？
PS:我也够无聊的了，这是第一次参加语言论战。
想起两个个笑话。老梗了。
一个女神和一个程序员在一起，女神说：“你要是让一群程序员吵得不可开交的话，今晚我就和你走。”程序员说了一句python是世界上最好的语言，接下来就吵起来了，等到之后大家吵得不可开交的时候女神告诉程序员，今晚上我是你的了。程序员说道：“你回去吧！，我必须说服他们Python是世界上最好的语言”。
一群男程序员酒后乱逛，正要集体侵犯一个女子。女子见势不妙，问：那你们说最好的 文本编辑器是哪个？程序员们就地讨论了三天三夜不欢而散，女子趁机顺利脱身
虽然Minecraft跨平台,但是GameSpy是以PC游戏给了Minecraft五颗星,正是在PC上火了,才会考虑迁移到移动平台.为了性能,Android上用C++完全合理.Minecraft支持Python Script,同样可以扩展.
还有这不是语言之争的问题,这是Java能不能用来开发游戏的问题,如果有人说Java不能开发赚钱的游戏,不能写游戏服务器端逻辑,我想就算是一个不玩Java的人也不会同意. 好吧，你也很无聊，来看评论。 - -#。
Java当然写的产品当然能赚钱，只不过是看这个钱赚的舒不舒服了。对一个程序员而言，能轻松的赚到钱（维护成本低，扩展型好，当然这个东西是和设计有关和语言无关的）才能算舒服吧。
我的观点是，Java没有成熟的服务端解决方案(框架)，也就意味着你需要做更多的基础工作，当然大牛用什么都无所谓。反观其他语言，比如C++有出名的ACE。连JS都有一个Pomelo（基于Node.js)。 Java呢，鄙人孤陋寡闻，没听说过。
还有一位同学提到，游戏开发是相对保守的。其实游戏行业不是保守，是因为做的东西都很稳定了，没有必要去频繁更新。用一些旧的但是稳定的技术，不能算保守。反而很多游戏开发人员是勇于尝试探索的，比如 Erlang在游戏服务端领域貌似受到重视了？
PS： 上大学的时候，用了1周，写过android应用，那时android最新版本才1.5（http://download.csdn.net/detail/ysleepers/2537506），接触过Java，开发效率真的没话说。不过从那之后就很反感Java，没什么特别的原因，就是 函数名字太长了。读着累。 用java写游戏服务器的我跳出来了，你提到的框架比如ACE只是一个网络框架，网络部分在游戏服务器中是很小的一个部分，同样的java网络框架，mina，netty都可以胜任，但是真正的网络框架还不如自己写，来来去去也就几百行，还能自己控制，剩下的数据存储效率等，都是游戏逻辑了，这个很语言也没关系，别说javaNIO的效率不高什么的，网络并发和吞吐语言上的那点差别真不大，关键是之所以用java是因为同样成本的程序员，java程序员写出来的比其他的要稳重一些，记住是同样成本。
引用来自“明月照大江”的答案引用来自“Tangsleepers”的答案引用来自“eechen”的答案引用来自“擅长被美女推倒”的答案引用来自“eechen”的答案引用来自“擅长被美女推倒”的答案
引用来自“eechen”的答案
引用来自“擅长被美女推倒”的答案
做东西要以赚钱为目的，用java做大型游戏很难卖出好价钱，因为这根本不会有老板投资做商业化运营，就算做出来 也就自己无聊玩玩，这纯粹浪费时间，php还能做桌面呢，但是做出来东西要有人要么，能赚钱么，做什么就用什么工具，做游戏就用C++，做web你可以用java/php，非要用java做大型游戏，只是无聊自己玩而已，
相信游戏控都知道有那么一个Java Platform的3D游戏&我的世界&Minecraft,GameSpy给予五星满分评价,绝对的热门游戏!
Minecraft不赚钱,别秀逗了,横跨PC/Mac/Linux/Android/iOS/Xbox平台,不赚钱,你去开发?
http://zh.wikipedia.org/wiki/Minecraft
Minecraft使用了引擎Lightweight Java Game Library(LWJGL),
LWJGL包含了对OpenGL的封装,引擎自身使用Java和C开发,采用宽松的BSD授权.
http://en.wikipedia.org/wiki/Lightweight_Java_Game_Library
你怎么拿PHP做桌面跟Java做游戏比,我觉得拿Python做桌面跟Java做游戏可能还比较恰当. 事实上用Java做游戏服务器端逻辑多的是,做游戏客户端的确实比C++少,但不代表不能做.
最后,支持楼主!
java做大型游戏不赚钱，不是说说的，这是事实，国内大型游戏公司，自己去做调查，你投资过游戏运营不，你敢拿一款大型JAVA游戏投资看看，亏不死你，这些东西不能看网上吹的，很简单你直接去找你老板问他敢不敢投资就行了，我们投资成功的大型游戏还真没见过java做的，至于java做页游或手机游戏，这能赚到点钱是真的，你拿着2个java例子，去多找个C++的例子比下，最多算半成品而已，
我只举了1个例子,使用引擎LWJGL的游戏Minecraft,不是2个,而且这个游戏相比C++游戏也绝非你想象中的半成品,没玩过就不要乱说了,另外有一个使用Irrlicht引擎和C++写的开源游戏Minetest,很像Minecraft,你看有谁玩?
说实话敢发这样的帖子的也就是java程序员，既没开发过大型游戏，也没运营过大型游戏就敢发这样的帖子，俺还真佩服，所谓无知者无畏，也不怕业内的兄弟笑话，赚不赚钱，俺已经说过了，不要看网上吹的，就去找你老板问他敢不敢运营，再多的话，上头有个兄弟，估计是业内的，俺就直接复制了，不打字了，
楼主，你的水平很好，只是你走错了路子。如果你的视野更开阔一点，不要眼里只有Java，你肯定能走的更远。
先说适用范围，用Java写不是不可以，只是只能用来写上层逻辑。你这个2D的，只有纹理贴图，在商业级的产品里，真的只是一些上层逻辑，用任何语言都可以做，用Java来做，只是一个蹩脚的选择而已。客户端如果需要做出一点效果来，比如 Particle ，或者 Shadow，用纯Java是无法胜任的。如果硬要用Java来做，也只能是用C来写关键部分，然后bind一个Java的JNI来写。例子就是android上的游戏，Java只是一个wrapper，关键的东西还是C/C++。
再说灵活性，做一般的服务器需求，有丰富的库和框架，Java还可以胜任。但是如果要商业级，产品级的游戏，Java写起来又显得太罗嗦，到时候JAVA的开发周期会比C++短吗，这个是一个仁者见仁的问题。如果你有大量的东西需要策划去做，你还觉得Java是一个可行的方案么？脚本策划会写JAVA代码吗，不会。但是脚本策划会写Lua代码。
最后再说性能，就拿web服务器来说，nginx + Lua 和 Apache。 谁性能高，不多说了吧，虽然普通的web服务 Apache足以。参考TEngine和OpenResty。
最后，在实际项目里。可能拿JAVA一门语言和 C + Lua 两门语言一起比，不太公平。但是，C + Lua两门语言的学习成本有JAVA高吗？主程写底层C，新人写Lua。为了达到灵活的需求，Java那些厚重的抽象层，和简单的脚本比起来。不比了，比多了都是泪。
上面提到的MC, MC无疑非常成功，Java功不可没。但是持续关注MC，你会发现，新版本的MC xbox360 (XNA C# + C++ ) 。 MCPE （Android C++, IOS OOC)，你有再看到Java的身影么？ 为什么后续版本没有继续选择Java？ IOS 不支持Java就算了， Android呢？Java可是Android开发的首选语言 ？为什么MC不选择Java呢？
PS:我也够无聊的了，这是第一次参加语言论战。
想起两个个笑话。老梗了。
一个女神和一个程序员在一起，女神说：“你要是让一群程序员吵得不可开交的话，今晚我就和你走。”程序员说了一句python是世界上最好的语言，接下来就吵起来了，等到之后大家吵得不可开交的时候女神告诉程序员，今晚上我是你的了。程序员说道：“你回去吧！，我必须说服他们Python是世界上最好的语言”。
一群男程序员酒后乱逛，正要集体侵犯一个女子。女子见势不妙，问：那你们说最好的 文本编辑器是哪个？程序员们就地讨论了三天三夜不欢而散，女子趁机顺利脱身
虽然Minecraft跨平台,但是GameSpy是以PC游戏给了Minecraft五颗星,正是在PC上火了,才会考虑迁移到移动平台.为了性能,Android上用C++完全合理.Minecraft支持Python Script,同样可以扩展.
还有这不是语言之争的问题,这是Java能不能用来开发游戏的问题,如果有人说Java不能开发赚钱的游戏,不能写游戏服务器端逻辑,我想就算是一个不玩Java的人也不会同意. 好吧，你也很无聊，来看评论。 - -#。
Java当然写的产品当然能赚钱，只不过是看这个钱赚的舒不舒服了。对一个程序员而言，能轻松的赚到钱（维护成本低，扩展型好，当然这个东西是和设计有关和语言无关的）才能算舒服吧。
我的观点是，Java没有成熟的服务端解决方案(框架)，也就意味着你需要做更多的基础工作，当然大牛用什么都无所谓。反观其他语言，比如C++有出名的ACE。连JS都有一个Pomelo（基于Node.js)。 Java呢，鄙人孤陋寡闻，没听说过。
还有一位同学提到，游戏开发是相对保守的。其实游戏行业不是保守，是因为做的东西都很稳定了，没有必要去频繁更新。用一些旧的但是稳定的技术，不能算保守。反而很多游戏开发人员是勇于尝试探索的，比如 Erlang在游戏服务端领域貌似受到重视了？
PS： 上大学的时候，用了1周，写过android应用，那时android最新版本才1.5（http://download.csdn.net/detail/ysleepers/2537506），接触过Java，开发效率真的没话说。不过从那之后就很反感Java，没什么特别的原因，就是 函数名字太长了。读着累。 用java写游戏服务器的我跳出来了，你提到的框架比如ACE只是一个网络框架，网络部分在游戏服务器中是很小的一个部分，同样的java网络框架，mina，netty都可以胜任，但是真正的网络框架还不如自己写，来来去去也就几百行，还能自己控制，剩下的数据存储效率等，都是游戏逻辑了，这个很语言也没关系，别说javaNIO的效率不高什么的，网络并发和吞吐语言上的那点差别真不大，关键是之所以用java是因为同样成本的程序员，java程序员写出来的比其他的要稳重一些，记住是同样成本。 http://blog.zoomquiet.org/pyblosxom/2012/03/
记得 去哪儿网,原先有业务使用了几十台 MySQL
前端使用 java 的jodb 进行连接
而因为代码写的比较糟糕,因为业务部门嘛,写的时候不会注意连接池的效率,
所以,每台主机的负载都非常 非常 高
而,我们后来改为nginx 作前端,結果一台nginx 就将以前几十台java 主机的业务抗了下来
通过封装成 http 接口,业务代码随便长连接/短连接,随便它搞,都撑得住了!
于是,被他们java 程序员描述成不可能的任务,被一台 nginx 主机就解决了
说效率没问题的，真的没问题吗？
--- 共有 2 条评论 ---
: +1 这的确是IO的问题 上面的只说了事实但是没说到事实的全部 你所说的效率并不是JAVA和C++的区别
数据库的IO读写，这个和语言真的是无关的，sql的执行时间才是关键，jdbc的作用也是使用socket和mysql数据库进行通信而已，无非是通信协议是数据库的网络协议，还有ngnix只是一个HTTP服务器，java的服务器比如Tomcat是javaEE应用服务器，是逻辑运算与页面生成的作用。我不太明白你这里的举例。
引用来自“天天向上1573”的答案 楼上有没有怀疑过3000帧是有问题的，即便你测是看到的就是3000帧
，假如一个 这么大的平面， 需要的色彩大约是4M (RGBA) , 不考虑其他因素，
4M&3000= 12G，(内存到显存的速度能达到12G每秒????) 还不说有很多地方重复贴图，也就是说C++能够在1秒内在内存生成
12G数据， 并且传递给显存， 还要将它画出来。&
难道真没问题吗？ 还有你的方法能看到内存到显存的数据交换？这3000帧难道不可能是因为你重复贴图，对方发现你你干的同一件事情，根本没真的工作？
还有 电影只有25帧就很流畅了，人眼超过“120”帧， 帧越高效果越烂。
你们都说你们写的C++有多快，我这台机器， 市面上的C++，3D游戏基本跑不起来， 巨卡。
真感觉不到快。 对,弄个手游传奇
厉害，很像我以前玩的要塞十字军