elseware/src/ship/packet/handler/room.rs

use libpso::packet::ship::*;
use libpso::packet::messages::*;
use crate::common::serverstate::ClientId;
use crate::common::leveltable::LEVEL_TABLE;
use crate::ship::ship::{SendShipPacket, ShipError, Rooms, Clients};
use crate::ship::location::{ClientLocation, RoomId, RoomLobby, ClientLocationError};
use crate::ship::packet::builder;
use crate::ship::room;
use crate::ship::items::state::ItemState;
use std::convert::{TryFrom};
use futures::StreamExt;

pub async fn create_room(id: ClientId,
                         create_room: &CreateRoom,
                         client_location: &mut ClientLocation,
                         clients: &mut Clients,
                         item_state: &mut ItemState,
                         rooms: &mut Rooms)
                         -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error> {
    let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
    let level = LEVEL_TABLE.get_level_from_exp(client.character.char_class, client.character.exp);
    match room::Difficulty::try_from(create_room.difficulty)? {
        room::Difficulty::Ultimate => {
            if level < 80 {
                return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 80 \nto create Ultimate rooms.".into())))].into_iter()))
            }
        },
        room::Difficulty::VeryHard => {
            if level < 40 {
                return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 40 \nto create Very Hard rooms.".into())))].into_iter()))
            }
        },
        room::Difficulty::Hard => {
            if level < 20 {
                return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 20 \nto create Hard rooms.".into())))].into_iter()))
            }
        },
        room::Difficulty::Normal => {},
    };

    let area = client_location.get_area(id).await.unwrap();
    let area_client = client_location.get_local_client(id).await.unwrap();
    let lobby_neighbors = client_location.get_client_neighbors(id).await.unwrap();
    let room_id = client_location.create_new_room(id).await.unwrap();
    let mut room = room::RoomState::from_create_room(create_room, client.character.section_id).unwrap();
    room.bursting = true;

    item_state.add_character_to_room(room_id, &client.character, area_client);

    let join_room = builder::room::join_room(id, clients, client_location, room_id, &room).await?;
    rooms[room_id.0] = Some(room);

    let mut result: Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send> = Box::new(
        vec![(id, SendShipPacket::JoinRoom(join_room))].into_iter()
    );
    if let Ok(leader) = client_location.get_area_leader(area).await {
        let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()));
        result = Box::new(result.chain(lobby_neighbors
                                       .into_iter()
                                       .map(move |c| {
                                           (c.client, leave_lobby.clone())
                                       })));
    }

    Ok(result)
}

pub async fn room_name_request(id: ClientId,
                               client_location: &ClientLocation,
                               rooms: &Rooms)
                               -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let area = client_location.get_area(id).await.unwrap();
    match area {
        RoomLobby::Room(room) => Box::new(vec![(id, SendShipPacket::RoomNameResponse(RoomNameResponse {name: rooms[room.0].as_ref().unwrap().name.clone()}))].into_iter()),
        RoomLobby::Lobby(_) => panic!()
    }
}

pub async fn join_room(id: ClientId,
                       pkt: &MenuSelect,
                       client_location: &mut ClientLocation,
                       clients: &mut Clients,
                       item_state: &mut ItemState,
                       rooms: &mut Rooms)
                       -> Result<Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send>, ShipError> {
    let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
    let level = LEVEL_TABLE.get_level_from_exp(client.character.char_class, client.character.exp);
    // let room = rooms.get(pkt.item as usize).ok_or(ShipError::InvalidRoom(pkt.item))?.as_ref().unwrap(); // clippy look what you made me do
    if let Some(room) = rooms.get(pkt.item as usize).ok_or(ShipError::InvalidRoom(pkt.item))? {

        match room.mode.difficulty() {
            room::Difficulty::Ultimate => {
                if level < 80 {
                    return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 80 \nto join Ultimate rooms.".into())))].into_iter()))
                }
            },
            room::Difficulty::VeryHard => {
                if level < 40 {
                    return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 40 \nto join Very Hard rooms.".into())))].into_iter()))
                }
            },
            room::Difficulty::Hard => {
                if level < 20 {
                    return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 20 \nto join Hard rooms.".into())))].into_iter()))
                }
            },
            _ => {},
        };

        let original_area = client_location.get_area(id).await.unwrap();
        let original_neighbors = client_location.get_client_neighbors(id).await.unwrap();
        if room.bursting {
            return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("player is bursting\nplease wait".into())))].into_iter()))
        }
        let room_id = RoomId(pkt.item as usize);
        let original_room_clients = client_location.get_clients_in_room(room_id).await.map_err(|err| -> ClientLocationError { err.into() })?;
        client_location.add_client_to_room(id, room_id).await.unwrap(); // TODO: show room full error or whatever

        let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
        let area_client = client_location.get_local_client(id).await.map_err(|err| -> ClientLocationError { err.into() })?;

        item_state.add_character_to_room(room_id, &client.character, area_client);

        let leader = client_location.get_room_leader(room_id).await.map_err(|err| -> ClientLocationError { err.into() })?;
        let join_room = builder::room::join_room(id, clients, client_location, room_id, room).await?;
        let add_to = builder::room::add_to_room(id, client, &area_client, &leader, item_state, room_id)?;

        let room = rooms.get_mut(room_id.0).unwrap().as_mut().unwrap();
        room.bursting = true;

        let mut result: Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send> = Box::new(
            vec![(id, SendShipPacket::JoinRoom(join_room))]
                .into_iter()
                .chain(original_room_clients.into_iter()
                    .map(move |c| (c.client, SendShipPacket::AddToRoom(add_to.clone())))
                ));

        if let Ok(leader) = client_location.get_area_leader(original_area).await {
            let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()));
            result = Box::new(result.chain(original_neighbors.into_iter()
                                        .map(move |c| (c.client, leave_lobby.clone()))))
        }

        Ok(result)
    } else {
        Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("Game is no longer active".into())))].into_iter()))
    }
}

pub async fn done_bursting(id: ClientId,
                           client_location: &ClientLocation,
                           rooms: &mut Rooms)
                           -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let area = client_location.get_area(id).await.unwrap();
    let mut rare_monster_list: Option<Vec<u16>> = None;
    if let RoomLobby::Room(room_id) = area {
        if let Some(room) = rooms.get_mut(room_id.0).unwrap().as_mut() {
            room.bursting = false;
            rare_monster_list = Some(room.maps.get_rare_monster_list());
        };
    }
    let area_client = client_location.get_local_client(id).await.unwrap(); // TODO: unwrap
    let mut result: Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send> = Box::new(
        client_location.get_client_neighbors(id).await.unwrap().into_iter() // TODO: unwrap
             .flat_map(move |client| {
                 vec![
                     (client.client, SendShipPacket::Message(Message::new(GameMessage::BurstDone(BurstDone {
                         client: area_client.local_client.id(),
                         target: 0
                     })))),
                 ]
             })
    );

    // TODO: check how often `done_bursting` is called. ie: make sure it's only used when joining a room and not each time a player warps in a pipe
    if let Some(rare_list) = rare_monster_list {
        let rare_monster_packet = SendShipPacket::RareMonsterList(builder::room::build_rare_monster_list(rare_list));
        result = Box::new(result.chain(vec![(id, rare_monster_packet)])); // TODO: make sure we arent clobbering `result` here
    }

    result
}

pub async fn request_room_list(id: ClientId,
                               client_location: &ClientLocation,
                               rooms: &Rooms)
                               -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let active_room_list = futures::stream::iter(rooms.iter())
        .enumerate()
        .filter_map(|(i, r)| async move {
            r.as_ref().map(|room| async move {
                RoomList {
                    menu_id: ROOM_MENU_ID,
                    item_id: i as u32,
                    difficulty: room.get_difficulty_for_room_list(),
                    players: client_location.get_clients_in_room(RoomId(i)).await.unwrap().len() as u8,
                    name: libpso::utf8_to_utf16_array!(room.name, 16),
                    episode: room.get_episode_for_room_list(),
                    flags: room.get_flags_for_room_list(),
                }
            })
        });
    let baseroom: RoomList = RoomList {
        menu_id: ROOM_MENU_ID,
        item_id: ROOM_MENU_ID,
        difficulty: 0x00,
        players: 0x00,
        name: libpso::utf8_to_utf16_array!("Room list menu", 16),
        episode: 0,
        flags: 0,
    };

    Box::new(vec![(id, SendShipPacket::RoomListResponse(RoomListResponse {
        baseroom,
        rooms: futures::future::join_all(active_room_list.collect::<Vec<_>>().await).await
    }))].into_iter())
}

pub async fn cool_62(id: ClientId,
                     cool_62: &Like62ButCooler,
                     client_location: &ClientLocation)
                     -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let target = cool_62.flag as u8;
    let cool_62 = cool_62.clone();
    Box::new(client_location.get_client_neighbors(id).await.unwrap().into_iter()
             .filter(move |client| client.local_client.id() == target)
             .map(move |client| {
                 (client.client, SendShipPacket::Like62ButCooler(cool_62.clone()))
             }))
}