public Vector3 get_camera_rotation(camera_dir dir)
{
Vector3 vc = new Vector3(12, 0,0);
switch (dir)
{
case camera_dir.front:
{
}
break;
case camera_dir.back:
{
vc.y = 180;
}
break;
case camera_dir.right:
{
vc.y = 270;
}
break;
case camera_dir.left:
{
vc.y = 90;
}
break;
}
return vc;
}
void camera_move_update()
{
if(_want_camera_dir != want_move_dir.no)
{
int current = (int)_camera_dir;
switch(_want_camera_dir)
{
case want_move_dir.left:
{
current -= 1;
}
break;
case want_move_dir.right:
{
current += 1;
}
break;
}
int special_temp = 0;
if (current < 0)
{
current = 3;
special_temp = 1;
}
else if (current >= 4)
{
current = 0;
special_temp = 2;
}
special_temp = 0;
Vector3 current_pos = get_camera_pos(_camera_dir);
Vector3 map_current_pos = get_map_camera_pos(_camera_dir);
Vector3 current_rotation = get_camera_rotation(_camera_dir);
Vector3 target_pos = get_camera_pos((camera_dir)current);
Vector3 map_target_pos = get_map_camera_pos((camera_dir)current);
Vector3 target_rotetion = get_camera_rotation((camera_dir)current);
Vector3 current_camera_pos = new Vector3();
Vector3 map_current_camera_pos = new Vector3();
Vector3 current_camera_roation = new Vector3();
int need_count = 20;
_move_count += 1;
current_camera_pos.x = current_pos.x + ((target_pos.x - current_pos.x) / need_count * _move_count);
current_camera_pos.y = current_pos.y + ((target_pos.y - current_pos.y) / need_count * _move_count);
current_camera_pos.z = current_pos.z + ((target_pos.z - current_pos.z) / need_count * _move_count);
map_current_camera_pos.x = map_current_pos.x + ((map_target_pos.x - map_current_pos.x) / need_count * _move_count);
map_current_camera_pos.y = map_current_pos.y + ((map_target_pos.y - map_current_pos.y) / need_count * _move_count);
map_current_camera_pos.z = map_current_pos.z + ((map_target_pos.z - map_current_pos.z) / need_count * _move_count);
current_camera_roation.x = current_rotation.x + ((target_rotetion.x - current_rotation.x) / need_count * _move_count);
if (special_temp == 0)
{
float temp_f = target_rotetion.y - current_rotation.y;
if(temp_f > 93)
{
temp_f = -90;
}
else if(temp_f < -93)
{
temp_f = 90;
}
current_camera_roation.y = current_rotation.y + ((temp_f) / need_count * _move_count);
}
current_camera_roation.z = current_rotation.z + ((target_rotetion.z - current_rotation.z) / need_count * _move_count);
Camera.main.transform.position = current_camera_pos;
Camera.main.transform.eulerAngles = current_camera_roation;
global_instance.Instance._ngui_edit_manager._camera_map.transform.position = map_current_camera_pos;
global_instance.Instance._ngui_edit_manager._camera_map.transform.eulerAngles = current_camera_roation;
if (_move_count == need_count)
{
_want_camera_dir = want_move_dir.no;
_move_count = 0;
_camera_dir = (camera_dir)current;
}
}
}
public Vector3 get_camera_pos(camera_dir dir)
{
Vector3 vc = _creature.get_position();
vc.y += 1.21f;
switch (dir)
{
case camera_dir.front:
{
vc.z -= 4.48f;
vc.x -= 0.5f;
}
break;
case camera_dir.back:
{
vc.z += 4.48f;
vc.x += 0.5f;
}
break;
case camera_dir.right:
{
vc.x += 4.48f;
vc.z -= 0.5f;
}
break;
case camera_dir.left:
{
vc.x -= 4.48f;
}
break;
}
return vc;
}
public void create_map()
{
create_enclosure();
MapData map_data = global_instance.Instance.GetMapData();
if(map_data != null)
{
for (int i = 0; i < map_data.width_; i++)
{
for (int j = 0; j < map_data.height_; j++)
{
int group = map_data.groups_[i, j];
if (group != 11)
{
int temp_x = (_max_x - map_data.width_) / 2 + i;
int temp_y = /*(_max_y - map_data.height_)+ */j + 20;
crash_mole mole_entry = global_instance.Instance._crash_manager.get_crash_mole_addr(temp_x, 9, temp_y)._crash_mole;
if (mole_entry == null)
{
crash_base_obj obj = null;
if (group != 10)
{
obj = global_instance.Instance._crash_manager.create_crash_obj(temp_x, temp_y);
}
else
{
obj = global_instance.Instance._crash_manager.create_flag_obj(temp_x, temp_y);
}
mole_entry = global_instance.Instance._crash_manager.create_crash_mole();
mole_entry.add_crash_obj(obj);
mole_entry._color_group = group;
global_instance.Instance._crash_manager.add_crash_mole(mole_entry);
create_mole(i, j, mole_entry);
}
}
}
}
}
for (int x = 0; x < (int)_max_x; x++)
{
for (int z = 0; z < (int)_max_z; z++)
{
for (int y = 0; y < (int)_max_y; y++)
{
if (_crash_objs[x, z, y]._crash_obj != null)
{
crash_base_obj entry = _crash_objs[x, z, y]._crash_obj;
switch(entry.get_obj_type())
{
case crash_obj_type.normal:
{
GameObject obj_temp = Object.Instantiate<GameObject>(_source_crash_mole_obj);
_Game_objs.Add(obj_temp);
crash_obj crash_obj_temp = (crash_obj)entry;
crash_obj_temp._grid = obj_temp.GetComponent<crashmolegrid>();
crash_obj_temp._grid.set_group(_crash_objs[x, z, y]._crash_obj._crash_mole._color_group);
}
break;
case crash_obj_type.flag:
{
GameObject obj_temp = Object.Instantiate<GameObject>(_source_flag_mole_obj);
_Game_objs.Add(obj_temp);
crash_obj_flag crash_temp = (crash_obj_flag)entry;
crash_temp._flag = obj_temp.GetComponent<crash_flag>();
}
break;
}
float x_temp = x * _grid_distance;
float z_temp = z * _grid_distance;
float y_temp = y * _grid_distance;
entry.set_position(x_temp, y_temp, z_temp);
}
}
}
}
foreach (crash_mole entry in _crash_moles_list)
{
entry.update_side();
}
if(_creature == null)
{
GameObject obj_temp = Resources.Load<GameObject>("prefab/creature");
GameObject obj_creature = Object.Instantiate<GameObject>(obj_temp);
_creature = obj_creature.GetComponent<creature>();
_creature.set_creature_type(creature_type.creature_2);
}
_camera_dir = camera_dir.front;
_want_camera_dir = want_move_dir.no;
_creature.gameObject.SetActive(true);
_creature.set_position(22, 2, 3);
_camera_dir = camera_dir.front;
_want_camera_dir = want_move_dir.no;
Camera.main.transform.position = get_camera_pos(_camera_dir);
Camera.main.transform.eulerAngles = get_camera_rotation(_camera_dir);
global_instance.Instance._ngui_edit_manager._camera_map.transform.position = get_map_camera_pos(_camera_dir);
global_instance.Instance._ngui_edit_manager._camera_map.transform.eulerAngles = get_camera_rotation(_camera_dir);
for (int i = 0 ;i < 4; i ++)
{
_dir_btn_down[i] = false;
}
next_update();
}
